diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet
index 4b02a16..083d50f 100644
--- a/books/bookvol10.2.pamphlet
+++ b/books/bookvol10.2.pamphlet
@@ -410,6 +410,7 @@ These are directly exported but not implemented:
 ++ Date Last Updated: 14 May 1991
 ++ Description:
 ++ Category for the inverse hyperbolic trigonometric functions;
+
 ArcHyperbolicFunctionCategory(): Category == with
     acosh: $ -> $ ++ acosh(x) returns the hyperbolic arc-cosine of x.
     acoth: $ -> $ ++ acoth(x) returns the hyperbolic arc-cotangent of x.
@@ -485,7 +486,9 @@ These are implemented by this category:
 ++ Author: ???
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the inverse trigonometric functions;
+++ Description:
+++ Category for the inverse trigonometric functions;
+
 ArcTrigonometricFunctionCategory(): Category == with
     acos: $ -> $       ++ acos(x) returns the arc-cosine of x.
     acot: $ -> $       ++ acot(x) returns the arc-cotangent of x.
@@ -546,7 +549,7 @@ is true if it has an operation $"*": (D,D) -> D$
 which is commutative.
 \item {\bf \cross{ATTREG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{ATTREG}{unitsKnown}}
 is true if a monoid (a multiplicative semigroup with a 1) has 
@@ -599,8 +602,9 @@ the real numbers''.
 
 <<category ATTREG AttributeRegistry>>=
 )abbrev category ATTREG AttributeRegistry
-
+++ Description:
 ++ This category exports the attributes in the AXIOM Library
+
 AttributeRegistry(): Category == with
   finiteAggregate
     ++ \spad{finiteAggregate} is true if it is an aggregate with a 
@@ -611,7 +615,7 @@ AttributeRegistry(): Category == with
   shallowlyMutable
     ++ \spad{shallowlyMutable} is true if its values
     ++ have immediate components that are updateable (mutable).
-    ++ Note: the properties of any component domain are irrevelant to the
+    ++ Note that the properties of any component domain are irrevelant to the
     ++ \spad{shallowlyMutable} proper.
   unitsKnown
     ++ \spad{unitsKnown} is true if a monoid (a multiplicative semigroup 
@@ -735,6 +739,7 @@ These are implemented by this category:
 ++ Description:
 ++ \spadtype{BasicType} is the basic category for describing a collection
 ++ of elements with \spadop{=} (equality).
+
 BasicType(): Category == with
       "=": (%,%) -> Boolean    ++ x=y tests if x and y are equal.
       "~=": (%,%) -> Boolean   ++ x~=y tests if x and y are not equal.
@@ -797,6 +802,7 @@ This is directly exported but not implemented:
 ++ Description:
 ++ A is coercible to B means any element of A can automatically be
 ++ converted into an element of B by the interpreter.
+
 CoercibleTo(S:Type): Category == with
     coerce: % -> S
       ++ coerce(a) transforms a into an element of S.
@@ -866,22 +872,24 @@ These are directly exported but not implemented:
 ++ Author: Manuel Bronstein
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the usual combinatorial functions;
+++ Description: 
+++ Category for the usual combinatorial functions;
+
 CombinatorialFunctionCategory(): Category == with
     binomial   : ($, $) -> $
       ++ binomial(n,r) returns the \spad{(n,r)} binomial coefficient
       ++ (often denoted in the literature by \spad{C(n,r)}).
-      ++ Note: \spad{C(n,r) = n!/(r!(n-r)!)} where \spad{n >= r >= 0}.
+      ++ Note that \spad{C(n,r) = n!/(r!(n-r)!)} where \spad{n >= r >= 0}.
       ++
       ++X [binomial(5,i) for i in 0..5]
     factorial  : $ -> $
       ++ factorial(n) computes the factorial of n
       ++ (denoted in the literature by \spad{n!})
-      ++ Note: \spad{n! = n (n-1)! when n > 0}; also, \spad{0! = 1}.
+      ++ Note that \spad{n! = n (n-1)! when n > 0}; also, \spad{0! = 1}.
     permutation: ($, $) -> $
       ++ permutation(n, m) returns the number of
       ++ permutations of n objects taken m at a time.
-      ++ Note: \spad{permutation(n,m) = n!/(n-m)!}.
+      ++ Note that \spad{permutation(n,m) = n!/(n-m)!}.
 
 @
 <<CFCAT.dotabb>>=
@@ -941,6 +949,7 @@ This is directly exported but not implemented:
 ++ A is convertible to B means any element of A
 ++ can be converted into an element of B,
 ++ but not automatically by the interpreter.
+
 ConvertibleTo(S:Type): Category == with
     convert: % -> S
       ++ convert(a) transforms a into an element of S.
@@ -1064,7 +1073,9 @@ These are implemented by this category:
 ++ Author: Manuel Bronstein
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the elementary functions;
+++ Description: 
+++ Category for the elementary functions;
+
 ElementaryFunctionCategory(): Category == with
     log : $ -> $       ++ log(x) returns the natural logarithm of x.
     exp : $ -> $       ++ exp(x) returns %e to the power x.
@@ -1136,6 +1147,7 @@ This is directly exported but not implemented:
 ++ Examples of eltable structures range from data structures, e.g. those
 ++ of type \spadtype{List}, to algebraic structures like 
 ++ \spadtype{Polynomial}.
+
 Eltable(S:SetCategory, Index:Type): Category == with
   elt : (%, S) -> Index
      ++ elt(u,i) (also written: u . i) returns the element of u indexed by i.
@@ -1218,7 +1230,9 @@ These are implemented by this category:
 ++ Author: ???
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the hyperbolic trigonometric functions;
+++ Description: 
+++ Category for the hyperbolic trigonometric functions;
+
 HyperbolicFunctionCategory(): Category == with
     cosh: $ -> $       ++ cosh(x) returns the hyperbolic cosine of x.
     coth: $ -> $       ++ coth(x) returns the hyperbolic cotangent of x.
@@ -1310,12 +1324,13 @@ These are implemented by this category:
 ++ Examples:
 ++ References:
 ++ Description:
-++   This category provides \spadfun{eval} operations.
-++   A domain may belong to this category if it is possible to make
-++   ``evaluation'' substitutions.  The difference between this
-++   and \spadtype{Evalable} is that the operations in this category
-++   specify the substitution as a pair of arguments rather than as
-++   an equation.
+++ This category provides \spadfun{eval} operations.
+++ A domain may belong to this category if it is possible to make
+++ ``evaluation'' substitutions.  The difference between this
+++ and \spadtype{Evalable} is that the operations in this category
+++ specify the substitution as a pair of arguments rather than as
+++ an equation.
+
 InnerEvalable(A:SetCategory, B:Type): Category == with
     eval: ($, A, B) -> $
        ++ eval(f, x, v) replaces x by v in f.
@@ -1672,11 +1687,12 @@ These exports come from \refto{ConvertibleTo}(Pattern(Float)):
 ++ Author: Manuel Bronstein
 ++ Date Created: 29 Nov 1989
 ++ Date Last Updated: 29 Nov 1989
-++ Description:
-++   An object S is Patternable over an object R if S can
-++   lift the conversions from R into \spadtype{Pattern(Integer)} and
-++   \spadtype{Pattern(Float)} to itself;
 ++ Keywords: pattern, matching.
+++ Description:
+++ An object S is Patternable over an object R if S can
+++ lift the conversions from R into \spadtype{Pattern(Integer)} and
+++ \spadtype{Pattern(Float)} to itself;
+
 Patternable(R:Type): Category == with
   if R has ConvertibleTo Pattern Integer then
            ConvertibleTo Pattern Integer
@@ -1746,7 +1762,9 @@ These are directly exported but not implemented:
 ++ Author: Manuel Bronstein
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the functions defined by integrals;
+++ Description:
+++ Category for the functions defined by integrals;
+
 PrimitiveFunctionCategory(): Category == with
     integral: ($, Symbol) -> $
       ++ integral(f, x) returns the formal integral of f dx.
@@ -1820,8 +1838,9 @@ These are implemented by this category:
 ++ Basic Operations: nthRoot, sqrt, **
 ++ Related Constructors:
 ++ Keywords: rational numbers
-++ Description: The \spad{RadicalCategory} is a model for the 
-++              rational numbers.
+++ Description:
+++ The \spad{RadicalCategory} is a model for the rational numbers.
+
 RadicalCategory(): Category == with
   sqrt   : % -> %
       ++ sqrt(x) returns the square root of x.
@@ -1913,6 +1932,7 @@ These are implemented by this category:
 ++ A is retractable to B means that some elementsif A can be converted
 ++ into elements of B and any element of B can be converted into an
 ++ element of A.
+
 RetractableTo(S: Type): Category == with
     coerce:       S -> %
       ++ coerce(a) transforms a into an element of %.
@@ -2050,7 +2070,9 @@ These are directly exported but not implemented:
 ++ Author: Manuel Bronstein
 ++ Date Created: ???
 ++ Date Last Updated: 11 May 1993
-++ Description: Category for the other special functions;
+++ Description:
+++ Category for the other special functions;
+
 SpecialFunctionCategory(): Category == with
     abs :      $ -> $
         ++ abs(x) returns the absolute value of x.
@@ -2146,7 +2168,9 @@ These are implemented by this category:
 ++ Author: ???
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the trigonometric functions;
+++ Description:
+++ Category for the trigonometric functions;
+
 TrigonometricFunctionCategory(): Category == with
     cos: $ -> $        ++ cos(x) returns the cosine of x.
     cot: $ -> $        ++ cot(x) returns the cotangent of x.
@@ -2213,7 +2237,9 @@ digraph pic {
 ++ Author: Richard Jenks
 ++ Date Created: 14 May 1992
 ++ Date Last Updated: 14 May 1992
-++ Description: The fundamental Type;
+++ Description:
+++ The fundamental Type;
+
 Type(): Category == with nil
 
 @
@@ -2293,24 +2319,23 @@ These are implemented by this category:
 ++ References:
 ++ Description:
 ++ The notion of aggregate serves to model any data structure aggregate,
-++ designating any collection of objects,
-++ with heterogenous or homogeneous members,
-++ with a finite or infinite number
-++ of members, explicitly or implicitly represented.
-++ An aggregate can in principle
-++ represent everything from a string of characters to abstract sets such
-++ as "the set of x satisfying relation {\em r(x)}"
+++ designating any collection of objects, with heterogenous or homogeneous
+++ members, with a finite or infinite number of members, explicitly or
+++ implicitly represented. An aggregate can in principle represent 
+++ everything from a string of characters to abstract sets such
+++ as "the set of x satisfying relation r(x)"
 ++ An attribute \spadatt{finiteAggregate} is used to assert that a domain
 ++ has a finite number of elements.
+
 Aggregate: Category == Type with
    eq?: (%,%) -> Boolean
      ++ eq?(u,v) tests if u and v are same objects.
    copy: % -> %
      ++ copy(u) returns a top-level (non-recursive) copy of u.
-     ++ Note: for collections, \axiom{copy(u) == [x for x in u]}.
+     ++ Note that for collections, \axiom{copy(u) == [x for x in u]}.
    empty: () -> %
      ++ empty()$D creates an aggregate of type D with 0 elements.
-     ++ Note: The {\em $D} can be dropped if understood by context,
+     ++ Note that The $D can be dropped if understood by context,
      ++ e.g. \axiom{u: D := empty()}.
    empty?: % -> Boolean
      ++ empty?(u) tests if u has 0 elements.
@@ -2403,8 +2428,9 @@ These exports come from \refto{CombinatorialFunctionCategory}():
 ++ Date Created: ???
 ++ Date Last Updated: 22 February 1993 (JHD/BMT)
 ++ Description:
-++   CombinatorialOpsCategory is the category obtaining by adjoining
-++   summations and products to the usual combinatorial operations;
+++ CombinatorialOpsCategory is the category obtaining by adjoining
+++ summations and products to the usual combinatorial operations;
+
 CombinatorialOpsCategory(): Category ==
   CombinatorialFunctionCategory with
     factorials : $ -> $
@@ -2476,7 +2502,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{ELTAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -2513,7 +2539,8 @@ These exports come from \refto{Eltable}():
 ++ For example, the list \axiom{[1,7,4]} can applied to 0,1, and 2 
 ++ respectively will return the integers 1,7, and 4; thus this list may 
 ++ be viewed as mapping 0 to 1, 1 to 7 and 2 to 4. In general, an aggregate
-++ can map members of a domain {\em Dom} to an image domain {\em Im}.
+++ can map members of a domain Dom to an image domain Im.
+
 EltableAggregate(Dom:SetCategory, Im:Type): Category ==
 -- This is separated from Eltable
 -- and series won't have to support qelt's and setelt's.
@@ -2532,12 +2559,12 @@ EltableAggregate(Dom:SetCategory, Im:Type): Category ==
        ++ is required, use the function \axiom{elt}.
     if % has shallowlyMutable then
        setelt : (%, Dom, Im) -> Im
-	   ++ setelt(u,x,y) sets the image of x to be y under u,
-	   ++ assuming x is in the domain of u.
-	   ++ Error: if x is not in the domain of u.
-	   -- this function will soon be renamed as setelt!.
+           ++ setelt(u,x,y) sets the image of x to be y under u,
+           ++ assuming x is in the domain of u.
+           ++ Error: if x is not in the domain of u.
+           -- this function will soon be renamed as setelt!.
        qsetelt_!: (%, Dom, Im) -> Im
-	   ++ qsetelt!(u,x,y) sets the image of \axiom{x} to be \axiom{y} 
+           ++ qsetelt!(u,x,y) sets the image of \axiom{x} to be \axiom{y} 
            ++ under \axiom{u}, without checking that \axiom{x} is in 
            ++ the domain of \axiom{u}.
            ++ If such a check is required use the function \axiom{setelt}.
@@ -2619,9 +2646,10 @@ These exports come from \refto{InnerEvalable}(R:SetCategory,R:SetCategory):
 ++ Examples:
 ++ References:
 ++ Description:
-++   This category provides \spadfun{eval} operations.
-++   A domain may belong to this category if it is possible to make
-++   ``evaluation'' substitutions.
+++ This category provides \spadfun{eval} operations.
+++ A domain may belong to this category if it is possible to make
+++ ``evaluation'' substitutions.
+
 Evalable(R:SetCategory): Category == InnerEvalable(R,R) with
     eval: ($, Equation R) -> $
        ++ eval(f,x = v) replaces x by v in f.
@@ -2725,8 +2753,8 @@ These exports come from \refto{CoercibleTo}(OutputForm):
 ++ References:
 ++ Description:
 ++ \axiomType{FortranProgramCategory} provides various models of
-++ FORTRAN subprograms.  These can be transformed into actual FORTRAN
-++ code.
+++ FORTRAN subprograms.  These can be transformed into actual FORTRAN code.
+
 FortranProgramCategory():Category == Join(Type,CoercibleTo OutputForm) with
     outputAsFortran : $ -> Void
     ++ \axiom{outputAsFortran(u)} translates \axiom{u} into a legal FORTRAN
@@ -2820,14 +2848,14 @@ These exports come from \refto{RetractableTo}(S:Type):
 <<category FRETRCT FullyRetractableTo>>=
 )abbrev category FRETRCT FullyRetractableTo
 ++ Author: Manuel Bronstein
-++ Description:
-++   A is fully retractable to B means that A is retractable to B, and,
-++   in addition, if B is retractable to the integers or rational
-++   numbers then so is A.
-++   In particular, what we are asserting is that there are no integers
-++   (rationals) in A which don't retract into B.
 ++ Date Created: March 1990
 ++ Date Last Updated: 9 April 1991
+++ Description:
+++ A is fully retractable to B means that A is retractable to B and
+++ if B is retractable to the integers or rational numbers then so is A.
+++ In particular, what we are asserting is that there are no integers
+++ (rationals) in A which don't retract into B.
+
 FullyRetractableTo(S: Type): Category == RetractableTo(S) with
     if (S has RetractableTo Integer) then RetractableTo Integer
     if (S has RetractableTo Fraction Integer) then
@@ -2960,11 +2988,12 @@ These exports come from \refto{Type}():
 ++ Author: Manuel Bronstein
 ++ Date Created: 28 Nov 1989
 ++ Date Last Updated: 29 Nov 1989
-++ Description:
-++   A set S is PatternMatchable over R if S can lift the
-++   pattern-matching functions of S over the integers and float
-++   to itself (necessary for matching in towers).
 ++ Keywords: pattern, matching.
+++ Description:
+++ A set S is PatternMatchable over R if S can lift the
+++ pattern-matching functions of S over the integers and float
+++ to itself (necessary for matching in towers).
+
 FullyPatternMatchable(R:Type): Category == Type with
   if R has PatternMatchable Integer then PatternMatchable Integer
   if R has PatternMatchable Float   then PatternMatchable Float
@@ -3056,15 +3085,15 @@ These exports come from \refto{BasicType}():
 ++ Related Constructors:
 ++ Keywords: boolean
 ++ Description:  
-++ `Logic' provides the basic operations for lattices,
-++ e.g., boolean algebra.
+++ `Logic' provides the basic operations for lattices, e.g., boolean algebra.
+
 Logic: Category == BasicType with
        _~:        % -> %
-	++ ~(x) returns the logical complement of x.
+        ++ ~(x) returns the logical complement of x.
        _/_\:       (%, %) -> %
-	++ \spadignore { /\ }returns the logical `meet', e.g. `and'.
+        ++ \spadignore { /\ }returns the logical `meet', e.g. `and'.
        _\_/:       (%, %) -> %
-	++ \spadignore{ \/ } returns the logical `join', e.g. `or'.
+        ++ \spadignore{ \/ } returns the logical `join', e.g. `or'.
   add
     _\_/(x: %,y: %) == _~( _/_\(_~(x), _~(y)))
 
@@ -3135,7 +3164,8 @@ These exports come from \refto{CoercibleTo}(OutputForm):
 ++ AMS Classifications:
 ++ Keywords: plot, graphics
 ++ References:
-++ Description: PlottablePlaneCurveCategory is the category of curves in the 
+++ Description: 
+++ PlottablePlaneCurveCategory is the category of curves in the 
 ++ plane which may be plotted via the graphics facilities.  Functions are 
 ++ provided for obtaining lists of lists of points, representing the
 ++ branches of the curve, and for determining the ranges of the
@@ -3231,7 +3261,8 @@ These exports come from \refto{CoercibleTo}(OutputForm):
 ++ AMS Classifications:
 ++ Keywords: plot, graphics
 ++ References:
-++ Description: PlottableSpaceCurveCategory is the category of curves in 
+++ Description: 
+++ PlottableSpaceCurveCategory is the category of curves in 
 ++ 3-space which may be plotted via the graphics facilities.  Functions are 
 ++ provided for obtaining lists of lists of points, representing the
 ++ branches of the curve, and for determining the ranges of the
@@ -3328,6 +3359,7 @@ These exports come from \refto{ConvertibleTo}(Float):
 ++ References:
 ++ Description:
 ++ The category of real numeric domains, i.e. convertible to floats.
+
 RealConstant(): Category ==
   Join(ConvertibleTo DoubleFloat, ConvertibleTo Float)
 
@@ -3420,8 +3452,8 @@ These are directly exported but not implemented:
 ++ Examples:
 ++ References:
 ++ Description:
-++   This category provides operations on ranges, or {\em segments}
-++   as they are called.
+++ This category provides operations on ranges, or segments
+++ as they are called.
 
 SegmentCategory(S:Type): Category == Type with
     SEGMENT: (S, S) -> %
@@ -3431,20 +3463,20 @@ SegmentCategory(S:Type): Category == Type with
         ++ \spad{n}-th element is used.
     lo: % -> S
         ++ lo(s) returns the first endpoint of s.
-        ++ Note: \spad{lo(l..h) = l}.
+        ++ Note that \spad{lo(l..h) = l}.
     hi: % -> S
         ++ hi(s) returns the second endpoint of s.
-        ++ Note: \spad{hi(l..h) = h}.
+        ++ Note that \spad{hi(l..h) = h}.
     low: % -> S
         ++ low(s) returns the first endpoint of s.
-        ++ Note: \spad{low(l..h) = l}.
+        ++ Note that \spad{low(l..h) = l}.
     high: % -> S
         ++ high(s) returns the second endpoint of s.
-        ++ Note: \spad{high(l..h) = h}.
+        ++ Note that \spad{high(l..h) = h}.
     incr: % -> Integer
         ++ incr(s) returns \spad{n}, where s is a segment in which every
         ++ \spad{n}-th element is used.
-        ++ Note: \spad{incr(l..h by n) = n}.
+        ++ Note that \spad{incr(l..h by n) = n}.
     segment: (S, S) -> %
         ++ segment(i,j) is an alternate way to create the segment 
         ++ \spad{i..j}.
@@ -3543,8 +3575,7 @@ These exports come from \refto{CoercibleTo}(OutputForm):
 )abbrev category SETCAT SetCategory
 ++ Author:
 ++ Date Created:
-++ Date Last Updated:
-++   November 10, 2009 tpd happy birthday
+++ Date Last Updated: November 10, 2009 tpd happy birthday
 ++ Basic Functions:
 ++ Related Constructors:
 ++ Also See:
@@ -3556,8 +3587,9 @@ These exports come from \refto{CoercibleTo}(OutputForm):
 ++ of elements with \spadop{=} (equality) and \spadfun{coerce} to 
 ++ output form.
 ++
-++ Conditional Attributes:
-++    canonical\tab{15}data structure equality is the same as \spadop{=}
+++ Conditional Attributes\br
+++ \tab{5}canonical\tab{5}data structure equality is the same as \spadop{=}
+
 SetCategory(): Category == Join(BasicType,CoercibleTo OutputForm) with
     hash: % -> SingleInteger  
       ++ hash(s) calculates a hash code for s.
@@ -3717,7 +3749,9 @@ These exports come from \refto{ElementaryFunctionCategory}():
 ++ Author: Manuel Bronstein
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the transcendental elementary functions;
+++ Description:
+++ Category for the transcendental elementary functions;
+
 TranscendentalFunctionCategory(): Category ==
     Join(TrigonometricFunctionCategory,ArcTrigonometricFunctionCategory,
          HyperbolicFunctionCategory,ArcHyperbolicFunctionCategory,
@@ -3858,12 +3892,13 @@ These exports come from \refto{SetCategory}():
 ++ Keywords:
 ++ References:
 ++ Description:
-++ the class of all additive (commutative) semigroups, i.e.
+++ The class of all additive (commutative) semigroups, i.e.
 ++ a set with a commutative and associative operation \spadop{+}.
 ++
-++ Axioms:
-++   \spad{associative("+":(%,%)->%)}\tab{30}\spad{ (x+y)+z = x+(y+z) }
-++   \spad{commutative("+":(%,%)->%)}\tab{30}\spad{ x+y = y+x }
+++ Axioms\br
+++ \tab{5}\spad{associative("+":(%,%)->%)}\tab{5}\spad{ (x+y)+z = x+(y+z) }\br
+++ \tab{6}\spad{commutative("+":(%,%)->%)}\tab{5}\spad{ x+y = y+x }
+
 AbelianSemiGroup(): Category == SetCategory with
       "+": (%,%) -> %                  ++ x+y computes the sum of x and y.
       "*": (PositiveInteger,%) -> %
@@ -3978,6 +4013,7 @@ These exports come from \refto{FortranProgramCategory}():
 ++ Description:
 ++ \axiomType{FortranFunctionCategory} is the category of arguments to
 ++ NAG Library routines which return (sets of) function values.
+
 FortranFunctionCategory():Category == FortranProgramCategory with
   coerce : List FortranCode -> $
     ++ coerce(e) takes an object from \spadtype{List FortranCode} and
@@ -4111,6 +4147,7 @@ These exports come from \refto{FortranProgramCategory}():
 ++ producing Functions and Subroutines when the input to these
 ++ is an AXIOM object of type \axiomType{Matrix} or in domains
 ++ involving \axiomType{FortranCode}.
+
 FortranMatrixCategory():Category == FortranProgramCategory with
     coerce : Matrix MachineFloat -> $
       ++ coerce(v) produces an ASP which returns the value of \spad{v}.
@@ -4351,6 +4388,7 @@ These exports come from \refto{FortranProgramCategory}():
 ++ producing Functions and Subroutines when the input to these
 ++ is an AXIOM object of type \axiomType{Vector} or in domains
 ++ involving \axiomType{FortranCode}.
+
 FortranVectorCategory():Category == FortranProgramCategory with
     coerce : Vector MachineFloat -> $
       ++ coerce(v) produces an ASP which returns the value of \spad{v}.
@@ -4458,6 +4496,7 @@ These exports come from \refto{FortranProgramCategory}():
 ++ Description:
 ++ \axiomType{FortranVectorFunctionCategory} is the catagory of arguments
 ++ to NAG Library routines which return the values of vectors of functions.
+
 FortranVectorFunctionCategory():Category == FortranProgramCategory with
     coerce : List FortranCode -> $
       ++ coerce(e) takes an object from \spadtype{List FortranCode} and
@@ -4603,8 +4642,9 @@ These exports come from \refto{InnerEvalable}(a:Symbol,b:SetCategory):
 ++ Examples:
 ++ References:
 ++ Description:
-++    This category provides a selection of evaluation operations
-++    depending on what the argument type R provides.
+++ This category provides a selection of evaluation operations
+++ depending on what the argument type R provides.
+
 FullyEvalableOver(R:SetCategory): Category == with
     map: (R -> R, $) -> $
         ++ map(f, ex) evaluates ex, applying f to values of type R in ex.
@@ -4740,10 +4780,10 @@ These exports come from SetCategory():
 ++ Examples:
 ++ References:
 ++ Description:
-++   This category provides an interface to operate on files in the
-++   computer's file system.  The precise method of naming files
-++   is determined by the Name parameter.  The type of the contents
-++   of the file is determined by S.
+++ This category provides an interface to operate on files in the
+++ computer's file system.  The precise method of naming files
+++ is determined by the Name parameter.  The type of the contents
+++ of the file is determined by S.
  
 FileCategory(Name, S): Category == FCdefinition where
     Name:      SetCategory
@@ -4880,9 +4920,9 @@ These exports come from \refto{SetCategory}():
 ++ to give a bijection between the finite set and an initial 
 ++ segment of positive integers.
 ++
-++ Axioms:
-++   \spad{lookup(index(n)) = n}
-++   \spad{index(lookup(s)) = s}
+++ Axioms:\br
+++ \tab{5}\spad{lookup(index(n)) = n}\br
+++ \tab{5}\spad{index(lookup(s)) = s}
 
 Finite(): Category == SetCategory with
       size: () ->  NonNegativeInteger
@@ -4999,7 +5039,8 @@ These exports come from \refto{SetCategory}():
 ++ Examples:
 ++ References:
 ++ Description:
-++   This category provides an interface to names in the file system.
+++ This category provides an interface to names in the file system.
+
 FileNameCategory(): Category == SetCategory with
    coerce: String -> %
      ++ coerce(s) converts a string to a file name
@@ -5135,15 +5176,15 @@ These exports come from \refto{SetCategory}():
 ++ Examples:
 ++ References: Algebra 2d Edition, MacLane and Birkhoff, MacMillan 1979
 ++ Description:
-++  GradedModule(R,E) denotes ``E-graded R-module'', i.e. collection of
-++  R-modules indexed by an abelian monoid E.
-++  An element \spad{g} of \spad{G[s]} for some specific \spad{s} in \spad{E}
-++  is said to be an element of \spad{G} with {\em degree} \spad{s}.
-++  Sums are defined in each module \spad{G[s]} so two elements of \spad{G}
-++  have a sum if they have the same degree.
+++ GradedModule(R,E) denotes ``E-graded R-module'', i.e. collection of
+++ R-modules indexed by an abelian monoid E.
+++ An element \spad{g} of \spad{G[s]} for some specific \spad{s} in \spad{E}
+++ is said to be an element of \spad{G} with degree \spad{s}.
+++ Sums are defined in each module \spad{G[s]} so two elements of \spad{G}
+++ have a sum if they have the same degree.
 ++
-++  Morphisms can be defined and composed by degree to give the
-++  mathematical category of graded modules.
+++ Morphisms can be defined and composed by degree to give the
+++ mathematical category of graded modules.
 
 GradedModule(R: CommutativeRing, E: AbelianMonoid): Category ==
     SetCategory with
@@ -5264,7 +5305,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{HOAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -5343,61 +5384,62 @@ These exports come from \refto{SetCategory}():
 ++ have a finite number of members.
 ++ Those with attribute \spadatt{shallowlyMutable} allow an element
 ++ to be modified or updated without changing its overall value.
+
 HomogeneousAggregate(S:Type): Category == Aggregate with
    if S has SetCategory then SetCategory
    if S has SetCategory then
       if S has Evalable S then Evalable S
-   map	   : (S->S,%) -> %
+   map           : (S->S,%) -> %
      ++ map(f,u) returns a copy of u with each element x replaced by f(x).
      ++ For collections, \axiom{map(f,u) = [f(x) for x in u]}.
    if % has shallowlyMutable then
      map_!: (S->S,%) -> %
-	++ map!(f,u) destructively replaces each element x of u 
+        ++ map!(f,u) destructively replaces each element x of u 
         ++ by \axiom{f(x)}.
    if % has finiteAggregate then
       any?: (S->Boolean,%) -> Boolean
-	++ any?(p,u) tests if \axiom{p(x)} is true for any element x of u.
-	++ Note: for collections,
-	++ \axiom{any?(p,u) = reduce(or,map(f,u),false,true)}.
+        ++ any?(p,u) tests if \axiom{p(x)} is true for any element x of u.
+        ++ Note that for collections,
+        ++ \axiom{any?(p,u) = reduce(or,map(f,u),false,true)}.
       every?: (S->Boolean,%) -> Boolean
-	++ every?(f,u) tests if p(x) is true for all elements x of u.
-	++ Note: for collections,
-	++ \axiom{every?(p,u) = reduce(and,map(f,u),true,false)}.
+        ++ every?(f,u) tests if p(x) is true for all elements x of u.
+        ++ Note that for collections,
+        ++ \axiom{every?(p,u) = reduce(and,map(f,u),true,false)}.
       count: (S->Boolean,%) -> NonNegativeInteger
-	++ count(p,u) returns the number of elements x in u
-	++ such that \axiom{p(x)} is true. For collections,
-	++ \axiom{count(p,u) = reduce(+,[1 for x in u | p(x)],0)}.
+        ++ count(p,u) returns the number of elements x in u
+        ++ such that \axiom{p(x)} is true. For collections,
+        ++ \axiom{count(p,u) = reduce(+,[1 for x in u | p(x)],0)}.
       parts: % -> List S
-	++ parts(u) returns a list of the consecutive elements of u.
-	++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}.
+        ++ parts(u) returns a list of the consecutive elements of u.
+        ++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}.
       members: % -> List S
-	++ members(u) returns a list of the consecutive elements of u.
-	++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}.
+        ++ members(u) returns a list of the consecutive elements of u.
+        ++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}.
       if S has SetCategory then
-	count: (S,%) -> NonNegativeInteger
-	  ++ count(x,u) returns the number of occurrences of x in u. For
-	  ++ collections, \axiom{count(x,u) = reduce(+,[x=y for y in u],0)}.
-	member?: (S,%) -> Boolean
-	  ++ member?(x,u) tests if x is a member of u.
-	  ++ For collections,
-	  ++ \axiom{member?(x,u) = reduce(or,[x=y for y in u],false)}.
+        count: (S,%) -> NonNegativeInteger
+          ++ count(x,u) returns the number of occurrences of x in u. For
+          ++ collections, \axiom{count(x,u) = reduce(+,[x=y for y in u],0)}.
+        member?: (S,%) -> Boolean
+          ++ member?(x,u) tests if x is a member of u.
+          ++ For collections,
+          ++ \axiom{member?(x,u) = reduce(or,[x=y for y in u],false)}.
   add
    if S has Evalable S then
      eval(u:%,l:List Equation S):% == map(x +-> eval(x,l),u)
    if % has finiteAggregate then
-     #c			  == # parts c
-     any?(f, c)		  == _or/[f x for x in parts c]
-     every?(f, c)	  == _and/[f x for x in parts c]
+     #c          == # parts c
+     any?(f, c)  == _or/[f x for x in parts c]
+     every?(f, c) == _and/[f x for x in parts c]
      count(f:S -> Boolean, c:%) == _+/[1 for x in parts c | f x]
-     members x		  == parts x
+     members x                  == parts x
      if S has SetCategory then
        count(s:S, x:%) == count(y +-> s = y, x)
        member?(e, c)   == any?(x +-> e = x,c)
        x = y ==
-	  size?(x, #y) and _and/[a = b for a in parts x for b in parts y]
+          size?(x, #y) and _and/[a = b for a in parts x for b in parts y]
        coerce(x:%):OutputForm ==
-	 bracket
-	    commaSeparate [a::OutputForm for a in parts x]$List(OutputForm)
+         bracket
+            commaSeparate [a::OutputForm for a in parts x]$List(OutputForm)
 
 @
 <<HOAGG.dotabb>>=
@@ -5672,7 +5714,9 @@ These exports come from \refto{TranscendentalFunctionCategory}():
 ++ Author: Manuel Bronstein
 ++ Date Created: ???
 ++ Date Last Updated: 14 May 1991
-++ Description: Category for the transcendental Liouvillian functions;
+++ Description:
+++ Category for the transcendental Liouvillian functions;
+
 LiouvillianFunctionCategory(): Category ==
   Join(PrimitiveFunctionCategory, TranscendentalFunctionCategory) with
     Ei      : $  -> $
@@ -5809,8 +5853,9 @@ These exports come from \refto{SetCategory}():
 ++  N. Jacobson: Structure and Representations of Jordan Algebras
 ++  AMS, Providence, 1968
 ++ Description:
-++  Monad is the class of all multiplicative monads, i.e. sets
-++  with a binary operation.
+++ Monad is the class of all multiplicative monads, i.e. sets
+++ with a binary operation.
+
 Monad(): Category == SetCategory with
       "*": (%,%) -> %
         ++ a*b is the product of \spad{a} and b in a set with
@@ -5962,12 +6007,15 @@ These exports come from \refto{SetCategory}():
 ++ describing the set of Numerical Integration \axiom{domains} with
 ++ \axiomFun{measure} and \axiomFun{numericalIntegration}.
 
-EDFE   ==> Expression DoubleFloat
-SOCDFE ==> Segment OrderedCompletion DoubleFloat
-DFE    ==> DoubleFloat
-NIAE   ==> Record(var:Symbol,fn:EDFE,range:SOCDFE,abserr:DFE,relerr:DFE)
-MDNIAE ==> Record(fn:EDFE,range:List SOCDFE,abserr:DFE,relerr:DFE)
-NumericalIntegrationCategory(): Category == SetCategory with
+NumericalIntegrationCategory(): Category == Exports where
+
+ EDFE   ==> Expression DoubleFloat
+ SOCDFE ==> Segment OrderedCompletion DoubleFloat
+ DFE    ==> DoubleFloat
+ NIAE   ==> Record(var:Symbol,fn:EDFE,range:SOCDFE,abserr:DFE,relerr:DFE)
+ MDNIAE ==> Record(fn:EDFE,range:List SOCDFE,abserr:DFE,relerr:DFE)
+
+ Exports ==> SetCategory with
 
   measure:(RoutinesTable,NIAE) -> _
    Record(measure:Float,explanations:String,extra:Result)
@@ -6110,13 +6158,17 @@ These exports come from \refto{SetCategory}():
 ++ describing the set of Numerical Optimization \axiom{domains} with
 ++ \axiomFun{measure} and \axiomFun{optimize}.
 
-LDFH   ==> List DoubleFloat
-LEDFH  ==> List Expression DoubleFloat
-LSAH   ==> Record(lfn:LEDFH, init:LDFH)
-EDFH   ==> Expression DoubleFloat
-LOCDFH ==> List OrderedCompletion DoubleFloat
-NOAH   ==> Record(fn:EDFH, init:LDFH, lb:LOCDFH, cf:LEDFH, ub:LOCDFH)
-NumericalOptimizationCategory(): Category == SetCategory with
+NumericalOptimizationCategory(): Category == Exports where
+
+ LDFH   ==> List DoubleFloat
+ LEDFH  ==> List Expression DoubleFloat
+ LSAH   ==> Record(lfn:LEDFH, init:LDFH)
+ EDFH   ==> Expression DoubleFloat
+ LOCDFH ==> List OrderedCompletion DoubleFloat
+ NOAH   ==> Record(fn:EDFH, init:LDFH, lb:LOCDFH, cf:LEDFH, ub:LOCDFH)
+
+ Exports ==> SetCategory with
+
   measure:(RoutinesTable,NOAH)->Record(measure:Float,explanations:String)
     ++ measure(R,args) calculates an estimate of the ability of a particular
     ++ method to solve an optimization problem.  
@@ -6254,12 +6306,15 @@ These exports come from \refto{SetCategory}():
 ++ \axiom{category} for describing the set of ODE solver \axiom{domains} 
 ++ with \axiomFun{measure} and \axiomFun{ODEsolve}.
 
-DFF   ==> DoubleFloat
-VEDFF ==> Vector Expression DoubleFloat
-LDFF  ==> List DoubleFloat
-EDFF  ==> Expression DoubleFloat
-ODEAF ==> Record(xinit:DFF,xend:DFF,fn:VEDFF,yinit:LDFF,intvals:LDFF,g:EDFF,abserr:DFF,relerr:DFF)
-OrdinaryDifferentialEquationsSolverCategory(): Category == SetCategory with
+OrdinaryDifferentialEquationsSolverCategory(): Category == Exports where
+
+ DFF   ==> DoubleFloat
+ VEDFF ==> Vector Expression DoubleFloat
+ LDFF  ==> List DoubleFloat
+ EDFF  ==> Expression DoubleFloat
+ ODEAF ==> Record(xinit:DFF,xend:DFF,fn:VEDFF,yinit:LDFF,intvals:LDFF,g:EDFF,abserr:DFF,relerr:DFF)
+
+ Exports ==> SetCategory with
 
   measure:(RoutinesTable,ODEAF) -> Record(measure:Float,explanations:String)
     ++ measure(R,args) calculates an estimate of the ability of a particular
@@ -6391,6 +6446,7 @@ These exports come from \refto{SetCategory}():
 ++ pair of elements \spad{(a,b)}
 ++ exactly one of the following relations holds \spad{a<b or a=b or b<a}
 ++ and the relation is transitive, i.e.  \spad{a<b and b<c => a<c}.
+
 OrderedSet(): Category == SetCategory with
     "<": (%,%) -> Boolean
       ++ x < y is a strict total ordering on the elements of the set.
@@ -6525,7 +6581,7 @@ These exports come from \refto{Dictionary}(S:SetCategory):
 ++ \axiom{category} for describing the set of PDE solver \axiom{domains} 
 ++ with \axiomFun{measure} and \axiomFun{PDEsolve}.
 
--- PDEA	==> Record(xmin:F,xmax:F,ymin:F,ymax:F,ngx:NNI,ngy:NNI,_
+-- PDEA        ==> Record(xmin:F,xmax:F,ymin:F,ymax:F,ngx:NNI,ngy:NNI,_
 --             pde:List Expression Float, bounds:List List Expression Float,_
 --             st:String, tol:DF)
 
@@ -6546,17 +6602,19 @@ These exports come from \refto{Dictionary}(S:SetCategory):
 --    ++ PDESolve(args) performs the integration of the
 --    ++ function given the strategy or method returned by \axiomFun{measure}.
 
-DFG   ==> DoubleFloat
-NNIG  ==> NonNegativeInteger
-INTG  ==> Integer
-MDFG  ==> Matrix DoubleFloat
-PDECG ==> Record(start:DFG, finish:DFG, grid:NNIG, boundaryType:INTG,
+PartialDifferentialEquationsSolverCategory(): Category == Exports where
+
+ DFG   ==> DoubleFloat
+ NNIG  ==> NonNegativeInteger
+ INTG  ==> Integer
+ MDFG  ==> Matrix DoubleFloat
+ PDECG ==> Record(start:DFG, finish:DFG, grid:NNIG, boundaryType:INTG,
                   dStart:MDFG, dFinish:MDFG)
-LEDFG ==> List Expression DoubleFloat
-PDEBG ==> Record(pde:LEDFG, constraints:List PDECG, f:List LEDFG, 
+ LEDFG ==> List Expression DoubleFloat
+ PDEBG ==> Record(pde:LEDFG, constraints:List PDECG, f:List LEDFG, 
                     st:String, tol:DFG)
-PartialDifferentialEquationsSolverCategory(): Category == SetCategory with
-
+ Exports ==> SetCategory with
+ 
   measure:(RoutinesTable,PDEBG) -> Record(measure:Float,explanations:String)
     ++ measure(R,args) calculates an estimate of the ability of a particular
     ++ method to solve a problem.  
@@ -6654,10 +6712,11 @@ These exports come from \refto{SetCategory}():
 ++ Author: Manuel Bronstein
 ++ Date Created: 28 Nov 1989
 ++ Date Last Updated: 15 Mar 1990
-++ Description:
-++   A set R is PatternMatchable over S if elements of R can
-++   be matched to patterns over S.
 ++ Keywords: pattern, matching.
+++ Description:
+++ A set R is PatternMatchable over S if elements of R can
+++ be matched to patterns over S.
+
 PatternMatchable(S:SetCategory): Category == SetCategory with
   patternMatch: (%, Pattern S, PatternMatchResult(S, %)) ->
                                                 PatternMatchResult(S, %)
@@ -6784,6 +6843,7 @@ These exports come from \refto{SetCategory}():
 ++ Description:
 ++ \axiomType{RealRootCharacterizationCategory} provides common acces
 ++ functions for all real root codings.
+
 RealRootCharacterizationCategory(TheField, ThePols ) : Category == PUB where
 
    TheField : Join(OrderedRing, Field)
@@ -6960,8 +7020,9 @@ These exports come from \refto{SegmentCategory}(OrderedRing):
 ++ Examples:
 ++ References:
 ++ Description:
-++   This category provides an interface for expanding segments to
-++   a stream of elements.
+++ This category provides an interface for expanding segments to
+++ a stream of elements.
+
 SegmentExpansionCategory(S: OrderedRing, L: StreamAggregate(S)): Category ==
     SegmentCategory(S) with
       expand: List % -> L
@@ -7082,11 +7143,12 @@ These exports come from \refto{SetCategory}():
 ++ the class of all multiplicative semigroups, i.e. a set
 ++ with an associative operation \spadop{*}.
 ++
-++ Axioms:
-++    \spad{associative("*":(%,%)->%)}\tab{30}\spad{ (x*y)*z = x*(y*z)}
+++ Axioms\br
+++ \tab{5}\spad{associative("*":(%,%)->%)}\tab{5}\spad{ (x*y)*z = x*(y*z)}
 ++
-++ Conditional attributes:
-++    \spad{commutative("*":(%,%)->%)}\tab{30}\spad{ x*y = y*x }
+++ Conditional attributes\br
+++ \tab{5}\spad{commutative("*":(%,%)->%)}\tab{5}\spad{ x*y = y*x }
+
 SemiGroup(): Category == SetCategory with
       "*": (%,%) -> %                  ++ x*y returns the product of x and y.
       "**": (%,PositiveInteger) -> %   ++ x**n returns the repeated product
@@ -7230,13 +7292,14 @@ These exports come from \refto{SetCategory}():
 ++ Date Created: July 1987
 ++ Date Last Modified: 23 May 1991
 ++ Description:
-++  This category allows the manipulation of Lisp values while keeping
-++  the grunge fairly localized.
+++ This category allows the manipulation of Lisp values while keeping
+++ the grunge fairly localized.
 --  The coerce to expression lets the
 --  values be displayed in the usual parenthesized way (displaying
 --  them as type Expression can cause the formatter to die, since
 --  certain magic cookies are in unexpected places).
 --  SMW July 87
+
 SExpressionCategory(Str, Sym, Int, Flt, Expr): Category == Decl where
     Str, Sym, Int, Flt, Expr: SetCategory
 
@@ -7400,8 +7463,9 @@ These exports come from \refto{SetCategory}():
 ++ of \spadfun{nextItem} is not required to reach all possible domain elements
 ++ starting from any initial element.
 ++
-++ Conditional attributes:
-++   infinite\tab{15}repeated \spad{nextItem}'s are never "failed".
+++ Conditional attributes\br
+++ \tab{5}infinite\tab{5}repeated nextItem's are never "failed".
+
 StepThrough(): Category == SetCategory with
       init: constant -> %
         ++ init() chooses an initial object for stepping.
@@ -7577,7 +7641,8 @@ These exports come from \refto{SetCategory}():
 ++ AMS Classifications:
 ++ Keywords: 
 ++ References:
-++ Description: The category ThreeSpaceCategory is used for creating 
+++ Description:
+++ The category ThreeSpaceCategory is used for creating 
 ++ three dimensional objects using functions for defining points, curves, 
 ++ polygons, constructs and the subspaces containing them.
 
@@ -7960,18 +8025,19 @@ These exports come from \refto{AbelianSemiGroup}():
 ++ The class of multiplicative monoids, i.e. semigroups with an
 ++ additive identity element.
 ++
-++ Axioms:
-++   \spad{leftIdentity("+":(%,%)->%,0)}\tab{30}\spad{ 0+x=x }
-++   \spad{rightIdentity("+":(%,%)->%,0)}\tab{30}\spad{ x+0=x }
+++ Axioms\br
+++ \tab{5}\spad{leftIdentity("+":(%,%)->%,0)}\tab{5}\spad{ 0+x=x }\br
+++ \tab{5}\spad{rightIdentity("+":(%,%)->%,0)}\tab{4}\spad{ x+0=x }
 -- following domain must be compiled with subsumption disabled
 -- define SourceLevelSubset to be EQUAL
+
 AbelianMonoid(): Category == AbelianSemiGroup with
       0: constant -> % 
-	++ 0 is the additive identity element.
+        ++ 0 is the additive identity element.
       sample: constant -> %
-	++ sample yields a value of type %
+        ++ sample yields a value of type %
       zero?: % -> Boolean
-	++ zero?(x) tests if x is equal to 0.
+        ++ zero?(x) tests if x is equal to 0.
       "*": (NonNegativeInteger,%) -> %
         ++ n * x is left-multiplication by a non negative integer
     add
@@ -8082,7 +8148,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{BGAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -8154,6 +8220,7 @@ These exports come from \refto{HomogeneousAggregate}(S:Type):
 ++ objects, and where the order in which objects are inserted determines 
 ++ the order of extraction.
 ++ Examples of bags are stacks, queues, and dequeues.
+
 BagAggregate(S:Type): Category == HomogeneousAggregate S with
    shallowlyMutable
      ++ shallowlyMutable means that elements of bags may be 
@@ -8262,8 +8329,9 @@ These exports come from \refto{OrderedSet}():
 ++ Date Created: 31 Oct 1988
 ++ Date Last Updated: 14 May 1991
 ++ Description:
-++   A cachable set is a set whose elements keep an integer as part
-++   of their structure.
+++ A cachable set is a set whose elements keep an integer as part
+++ of their structure.
+
 CachableSet: Category == OrderedSet with
   position   : % -> NonNegativeInteger
     ++ position(x) returns the integer n associated to x.
@@ -8452,6 +8520,7 @@ These exports come from \refto{ConvertibleTo}(S:Type):
 ++ data type, except with an initial lower case letter, e.g.
 ++ \spadfun{list} for \spadtype{List},
 ++ \spadfun{flexibleArray} for \spadtype{FlexibleArray}, and so on.
+
 Collection(S:Type): Category == HomogeneousAggregate(S) with
    construct: List S -> %
      ++ \axiom{construct(x,y,...,z)} returns the collection of elements 
@@ -8463,52 +8532,52 @@ Collection(S:Type): Category == HomogeneousAggregate(S) with
      ++ and "failed" otherwise.
    if % has finiteAggregate then
       reduce: ((S,S)->S,%) -> S
-	++ reduce(f,u) reduces the binary operation f across u. For example,
-	++ if u is \axiom{[x,y,...,z]} then \axiom{reduce(f,u)} 
+        ++ reduce(f,u) reduces the binary operation f across u. For example,
+        ++ if u is \axiom{[x,y,...,z]} then \axiom{reduce(f,u)} 
         ++ returns \axiom{f(..f(f(x,y),...),z)}.
-	++ Note: if u has one element x, \axiom{reduce(f,u)} returns x.
-	++ Error: if u is empty.
+        ++ Note that if u has one element x, \axiom{reduce(f,u)} returns x.
+        ++ Error: if u is empty.
         ++
         ++C )clear all
         ++X reduce(+,[C[i]*x**i for i in 1..5])
 
       reduce: ((S,S)->S,%,S) -> S
-	++ reduce(f,u,x) reduces the binary operation f across u, where x is
-	++ the identity operation of f.
-	++ Same as \axiom{reduce(f,u)} if u has 2 or more elements.
-	++ Returns \axiom{f(x,y)} if u has one element y,
-	++ x if u is empty.
-	++ For example, \axiom{reduce(+,u,0)} returns the
-	++ sum of the elements of u.
+        ++ reduce(f,u,x) reduces the binary operation f across u, where x is
+        ++ the identity operation of f.
+        ++ Same as \axiom{reduce(f,u)} if u has 2 or more elements.
+        ++ Returns \axiom{f(x,y)} if u has one element y,
+        ++ x if u is empty.
+        ++ For example, \axiom{reduce(+,u,0)} returns the
+        ++ sum of the elements of u.
       remove: (S->Boolean,%) -> %
-	++ remove(p,u) returns a copy of u removing all elements x such that
-	++ \axiom{p(x)} is true.
-	++ Note: \axiom{remove(p,u) == [x for x in u | not p(x)]}.
+        ++ remove(p,u) returns a copy of u removing all elements x such that
+        ++ \axiom{p(x)} is true.
+        ++ Note that \axiom{remove(p,u) == [x for x in u | not p(x)]}.
       select: (S->Boolean,%) -> %
-	++ select(p,u) returns a copy of u containing only those elements 
-	++ such \axiom{p(x)} is true.
-	++ Note: \axiom{select(p,u) == [x for x in u | p(x)]}.
+        ++ select(p,u) returns a copy of u containing only those elements 
+        ++ such \axiom{p(x)} is true.
+        ++ Note that \axiom{select(p,u) == [x for x in u | p(x)]}.
       if S has SetCategory then
-	reduce: ((S,S)->S,%,S,S) -> S
-	  ++ reduce(f,u,x,z) reduces the binary operation f across u, 
-	  ++ stopping when an "absorbing element" z is encountered.
-	  ++ As for \axiom{reduce(f,u,x)}, x is the identity operation of f.
-	  ++ Same as \axiom{reduce(f,u,x)} when u contains no element z.
-	  ++ Thus the third argument x is returned when u is empty.
-	remove: (S,%) -> %
-	  ++ remove(x,u) returns a copy of u with all
-	  ++ elements \axiom{y = x} removed.
-	  ++ Note: \axiom{remove(y,c) == [x for x in c | x ^= y]}.
-	removeDuplicates: % -> %
-	  ++ removeDuplicates(u) returns a copy of u with all duplicates 
+        reduce: ((S,S)->S,%,S,S) -> S
+          ++ reduce(f,u,x,z) reduces the binary operation f across u, 
+          ++ stopping when an "absorbing element" z is encountered.
+          ++ As for \axiom{reduce(f,u,x)}, x is the identity operation of f.
+          ++ Same as \axiom{reduce(f,u,x)} when u contains no element z.
+          ++ Thus the third argument x is returned when u is empty.
+        remove: (S,%) -> %
+          ++ remove(x,u) returns a copy of u with all
+          ++ elements \axiom{y = x} removed.
+          ++ Note that \axiom{remove(y,c) == [x for x in c | x ^= y]}.
+        removeDuplicates: % -> %
+          ++ removeDuplicates(u) returns a copy of u with all duplicates 
           ++ removed.
    if S has ConvertibleTo InputForm then ConvertibleTo InputForm
  add
    if % has finiteAggregate then
-     #c			  == # parts c
+     #c                          == # parts c
      count(f:S -> Boolean, c:%) == _+/[1 for x in parts c | f x]
-     any?(f, c)		  == _or/[f x for x in parts c]
-     every?(f, c)	  == _and/[f x for x in parts c]
+     any?(f, c)                  == _or/[f x for x in parts c]
+     every?(f, c)          == _and/[f x for x in parts c]
      find(f:S -> Boolean, c:%) == find(f, parts c)
      reduce(f:(S,S)->S, x:%) == reduce(f, parts x)
      reduce(f:(S,S)->S, x:%, s:S) == reduce(f, parts x, s)
@@ -8652,50 +8721,50 @@ These exports come from \refto{RetractableTo}(S:OrderedSet):
 ++ Keywords: differential indeterminates, ranking, order, weight
 ++ References:Ritt, J.F. "Differential Algebra" (Dover, 1950).
 ++ Description:
-++   \spadtype{DifferentialVariableCategory} constructs the
-++   set of derivatives of a given set of
-++   (ordinary) differential indeterminates.
-++   If x,...,y is an ordered set of differential indeterminates,
-++   and the prime notation is used for differentiation, then
-++   the set of derivatives (including
-++   zero-th order) of the differential indeterminates is
-++   x,\spad{x'},\spad{x''},..., y,\spad{y'},\spad{y''},...
-++   (Note: in the interpreter, the n-th derivative of y is displayed as
-++   y with a subscript n.)  This set is
-++   viewed as a set of algebraic indeterminates, totally ordered in a
-++   way compatible with differentiation and the given order on the
-++   differential indeterminates.  Such a total order is called a
-++   ranking of the differential indeterminates.
+++ \spadtype{DifferentialVariableCategory} constructs the
+++ set of derivatives of a given set of
+++ (ordinary) differential indeterminates.
+++ If x,...,y is an ordered set of differential indeterminates,
+++ and the prime notation is used for differentiation, then
+++ the set of derivatives (including
+++ zero-th order) of the differential indeterminates is
+++ x,\spad{x'},\spad{x''},..., y,\spad{y'},\spad{y''},...
+++ (Note that in the interpreter, the n-th derivative of y is displayed as
+++ y with a subscript n.)  This set is
+++ viewed as a set of algebraic indeterminates, totally ordered in a
+++ way compatible with differentiation and the given order on the
+++ differential indeterminates.  Such a total order is called a
+++ ranking of the differential indeterminates.
 ++
-++   A domain in this category is needed to construct a differential
-++   polynomial domain.  Differential polynomials are ordered
-++   by a ranking on the derivatives,  and by an order (extending the
-++   ranking) on
-++   on the set of differential monomials.  One may thus associate
-++   a domain in this category with a ranking of the differential
-++   indeterminates, just as one associates a domain in the category
-++   \spadtype{OrderedAbelianMonoidSup} with an ordering of the set of
-++   monomials in a set of algebraic indeterminates.  The ranking
-++   is specified through the binary relation \spadfun{<}.
-++   For example, one may define
-++   one derivative to be less than another by lexicographically comparing
-++   first the \spadfun{order}, then the given order of the differential
-++   indeterminates appearing in the derivatives.  This is the default
-++   implementation.
+++ A domain in this category is needed to construct a differential
+++ polynomial domain.  Differential polynomials are ordered
+++ by a ranking on the derivatives,  and by an order (extending the
+++ ranking) on
+++ on the set of differential monomials.  One may thus associate
+++ a domain in this category with a ranking of the differential
+++ indeterminates, just as one associates a domain in the category
+++ \spadtype{OrderedAbelianMonoidSup} with an ordering of the set of
+++ monomials in a set of algebraic indeterminates.  The ranking
+++ is specified through the binary relation \spadfun{<}.
+++ For example, one may define
+++ one derivative to be less than another by lexicographically comparing
+++ first the \spadfun{order}, then the given order of the differential
+++ indeterminates appearing in the derivatives.  This is the default
+++ implementation.
 ++
-++   The notion of weight generalizes that of degree.  A
-++   polynomial domain may be made into a graded ring
-++   if a weight function is given on the set of indeterminates,
-++   Very often, a grading is the first step in ordering the set of
-++   monomials.  For differential polynomial domains, this
-++   constructor provides a function \spadfun{weight}, which
-++   allows the assignment of a non-negative number to each derivative of a
-++   differential indeterminate.  For example, one may define
-++   the weight of a derivative to be simply its \spadfun{order}
-++   (this is the default assignment).
-++   This weight function can then be extended to the set of
-++   all differential polynomials, providing a graded ring
-++   structure.
+++ The notion of weight generalizes that of degree.  A
+++ polynomial domain may be made into a graded ring
+++ if a weight function is given on the set of indeterminates,
+++ Very often, a grading is the first step in ordering the set of
+++ monomials.  For differential polynomial domains, this
+++ constructor provides a function \spadfun{weight}, which
+++ allows the assignment of a non-negative number to each derivative of a
+++ differential indeterminate.  For example, one may define
+++ the weight of a derivative to be simply its \spadfun{order}
+++ (this is the default assignment).
+++ This weight function can then be extended to the set of
+++ all differential polynomials, providing a graded ring structure.
+
 DifferentialVariableCategory(S:OrderedSet): Category ==
   Join(OrderedSet, RetractableTo S) with
     -- Examples:
@@ -8946,9 +9015,10 @@ These exports come from \refto{Evalable}(a:SetCategory):
 ++ Author: Manuel Bronstein
 ++ Date Created: 22 March 1988
 ++ Date Last Updated: 27 May 1994
+++ Keywords: operator, kernel, expression, space.
 ++ Description:
 ++ An expression space is a set which is closed under certain operators;
-++ Keywords: operator, kernel, expression, space.
+
 ExpressionSpace(): Category == Defn where
   N   ==> NonNegativeInteger
   K   ==> Kernel %
@@ -9407,12 +9477,12 @@ These exports come from \refto{RetractableTo}(R:CommutativeRing):
 ++ Examples:
 ++ References: Encyclopedic Dictionary of Mathematics, MIT Press, 1977
 ++ Description:
-++  GradedAlgebra(R,E) denotes ``E-graded R-algebra''.
-++  A graded algebra is a graded module together with a degree preserving
-++  R-linear map, called the {\em product}.
+++ GradedAlgebra(R,E) denotes ``E-graded R-algebra''.
+++ A graded algebra is a graded module together with a degree preserving
+++ R-linear map, called the product.
 ++
-++  The name ``product'' is written out in full so inner and outer products
-++  with the same mapping type can be distinguished by name.
+++ The name ``product'' is written out in full so inner and outer products
+++ with the same mapping type can be distinguished by name.
 
 GradedAlgebra(R: CommutativeRing, E: AbelianMonoid): Category ==
     Join(GradedModule(R, E),RetractableTo(R)) with
@@ -9551,7 +9621,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{IXAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -9638,6 +9708,7 @@ These exports come from \refto{EltableAggregate}(Index:SetCategory,Entry:Type):
 ++ For example, a one-dimensional-array is an indexed aggregate where
 ++ the index is an integer.  Also, a table is an indexed aggregate
 ++ where the indices and entries may have any type.
+
 IndexedAggregate(Index: SetCategory, Entry: Type): Category ==
   Join(HomogeneousAggregate(Entry), EltableAggregate(Index, Entry)) with
    entries: % -> List Entry
@@ -9656,30 +9727,30 @@ IndexedAggregate(Index: SetCategory, Entry: Type): Category ==
 --    ++    c.i = f(a(i,x),b(i,x)) | index?(i,a) or index?(i,b)
    if Entry has SetCategory and % has finiteAggregate then
       entry?: (Entry,%) -> Boolean
-	++ entry?(x,u) tests if x equals \axiom{u . i} for some index i.
+        ++ entry?(x,u) tests if x equals \axiom{u . i} for some index i.
    if Index has OrderedSet then
       maxIndex: % -> Index
-	++ maxIndex(u) returns the maximum index i of aggregate u.
-	++ Note: in general,
-	++ \axiom{maxIndex(u) = reduce(max,[i for i in indices u])};
-	++ if u is a list, \axiom{maxIndex(u) = #u}.
+        ++ maxIndex(u) returns the maximum index i of aggregate u.
+        ++ Note that in general,
+        ++ \axiom{maxIndex(u) = reduce(max,[i for i in indices u])};
+        ++ if u is a list, \axiom{maxIndex(u) = #u}.
       minIndex: % -> Index
-	++ minIndex(u) returns the minimum index i of aggregate u.
-	++ Note: in general,
-	++ \axiom{minIndex(a) = reduce(min,[i for i in indices a])};
-	++ for lists, \axiom{minIndex(a) = 1}.
+        ++ minIndex(u) returns the minimum index i of aggregate u.
+        ++ Note that in general,
+        ++ \axiom{minIndex(a) = reduce(min,[i for i in indices a])};
+        ++ for lists, \axiom{minIndex(a) = 1}.
       first   : % -> Entry
-	++ first(u) returns the first element x of u.
-	++ Note: for collections, \axiom{first([x,y,...,z]) = x}.
-	++ Error: if u is empty.
+        ++ first(u) returns the first element x of u.
+        ++ Note that for collections, \axiom{first([x,y,...,z]) = x}.
+        ++ Error: if u is empty.
 
    if % has shallowlyMutable then
       fill_!: (%,Entry) -> %
-	++ fill!(u,x) replaces each entry in aggregate u by x.
-	++ The modified u is returned as value.
+        ++ fill!(u,x) replaces each entry in aggregate u by x.
+        ++ The modified u is returned as value.
       swap_!: (%,Index,Index) -> Void
-	++ swap!(u,i,j) interchanges elements i and j of aggregate u.
-	++ No meaningful value is returned.
+        ++ swap!(u,i,j) interchanges elements i and j of aggregate u.
+        ++ No meaningful value is returned.
  add
   elt(a, i, x) == (index?(i, a) => qelt(a, i); x)
 
@@ -9834,16 +9905,19 @@ These exports come from \refto{Monad}():
 ++ Keywords:
 ++ Keywords: Monad with unit, binary operation
 ++ Reference:
-++  N. Jacobson: Structure and Representations of Jordan Algebras
-++  AMS, Providence, 1968
+++ N. Jacobson: Structure and Representations of Jordan Algebras
+++ AMS, Providence, 1968
 ++ Description:
-++  MonadWithUnit is the class of multiplicative monads with unit,
-++  i.e. sets with a binary operation and a unit element.
-++ Axioms
-++    leftIdentity("*":(%,%)->%,1)   \tab{30} 1*x=x
-++    rightIdentity("*":(%,%)->%,1)  \tab{30} x*1=x
-++ Common Additional Axioms
-++    unitsKnown---if "recip" says "failed", that PROVES input wasn't a unit
+++ MonadWithUnit is the class of multiplicative monads with unit,
+++ i.e. sets with a binary operation and a unit element.
+++
+++ Axioms\br
+++ \tab{5}leftIdentity("*":(%,%)->%,1) e.g. 1*x=x\br
+++ \tab{5}rightIdentity("*":(%,%)->%,1) e.g x*1=x
+++
+++ Common Additional Axioms\br
+++ \tab{5}unitsKnown - if "recip" says "failed", it PROVES input wasn't a unit
+
 MonadWithUnit(): Category == Monad with
       1: constant ->  %
         ++ 1 returns the unit element, denoted by 1.
@@ -10011,12 +10085,13 @@ These exports come from \refto{SemiGroup}():
 ++ The class of multiplicative monoids, i.e. semigroups with a
 ++ multiplicative identity element.
 ++
-++ Axioms:
-++    \spad{leftIdentity("*":(%,%)->%,1)}\tab{30}\spad{1*x=x}
-++    \spad{rightIdentity("*":(%,%)->%,1)}\tab{30}\spad{x*1=x}
+++ Axioms\br
+++ \tab{5}\spad{leftIdentity("*":(%,%)->%,1)}\tab{5}\spad{1*x=x}\br
+++ \tab{5}\spad{rightIdentity("*":(%,%)->%,1)}\tab{4}\spad{x*1=x}
 ++
-++ Conditional attributes:
-++    unitsKnown\tab{15}\spadfun{recip} only returns "failed" on non-units
+++ Conditional attributes\br
+++ \tab{5}unitsKnown - \spadfun{recip} only returns "failed" on non-units
+
 Monoid(): Category == SemiGroup with
       1: constant ->  %
         ++ 1 is the multiplicative identity.
@@ -10270,7 +10345,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{RCAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -10348,12 +10423,13 @@ These exports come from \refto{HomogeneousAggregate}(S:Type):
 ++ Description:
 ++ A recursive aggregate over a type S is a model for a
 ++ a directed graph containing values of type S.
-++ Recursively, a recursive aggregate is a {\em node}
+++ Recursively, a recursive aggregate is a node
 ++ consisting of a \spadfun{value} from S and 0 or more \spadfun{children}
 ++ which are recursive aggregates.
 ++ A node with no children is called a \spadfun{leaf} node.
 ++ A recursive aggregate may be cyclic for which some operations as noted
 ++ may go into an infinite loop.
+
 RecursiveAggregate(S:Type): Category == HomogeneousAggregate(S) with
    children: % -> List %
      ++ children(u) returns a list of the children of aggregate u.
@@ -10377,19 +10453,19 @@ RecursiveAggregate(S:Type): Category == HomogeneousAggregate(S) with
      ++ distance(u,v) returns the path length (an integer) from node u to v.
    if S has SetCategory then
       child?: (%,%) -> Boolean
-	++ child?(u,v) tests if node u is a child of node v.
+        ++ child?(u,v) tests if node u is a child of node v.
       node?: (%,%) -> Boolean
-	++ node?(u,v) tests if node u is contained in node v
-	++ (either as a child, a child of a child, etc.).
+        ++ node?(u,v) tests if node u is contained in node v
+        ++ (either as a child, a child of a child, etc.).
    if % has shallowlyMutable then
       setchildren_!: (%,List %)->%
-	++ setchildren!(u,v) replaces the current children of node u
-	++ with the members of v in left-to-right order.
+        ++ setchildren!(u,v) replaces the current children of node u
+        ++ with the members of v in left-to-right order.
       setelt: (%,"value",S) -> S
-	++ setelt(a,"value",x) (also written \axiom{a . value := x})
-	++ is equivalent to \axiom{setvalue!(a,x)}
+        ++ setelt(a,"value",x) (also written \axiom{a . value := x})
+        ++ is equivalent to \axiom{setvalue!(a,x)}
       setvalue_!: (%,S) -> S
-	++ setvalue!(u,x) sets the value of node u to x.
+        ++ setvalue!(u,x) sets the value of node u to x.
  add
    elt(x,"value") == value x
    if % has shallowlyMutable then
@@ -10498,7 +10574,7 @@ first column in an array and vice versa.
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{ARR2CAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -10507,7 +10583,7 @@ domain are irrevelant to the shallowlyMutable proper.
 \begin{itemize}
 \item {\bf \cross{ARR2CAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -10571,13 +10647,15 @@ These exports come from \refto{HomogeneousAggregate}(R:Type)
 
 <<category ARR2CAT TwoDimensionalArrayCategory>>=
 )abbrev category ARR2CAT TwoDimensionalArrayCategory
-++ Two dimensional array categories and domains
 ++ Author:
 ++ Date Created: 27 October 1989
 ++ Date Last Updated: 27 June 1990
 ++ Keywords: array, data structure
 ++ Examples:
 ++ References:
+++ Description:
+++ Two dimensional array categories and domains
+
 TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where
  R   : Type
  Row : FiniteLinearAggregate R
@@ -11045,7 +11123,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{BRAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -11131,6 +11209,7 @@ These exports come from \refto{RecursiveAggregate}(S:Type)
 ++ Description:
 ++ A binary-recursive aggregate has 0, 1 or 2 children and serves
 ++ as a model for a binary tree or a doubly-linked aggregate structure
+
 BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with
    -- needs preorder, inorder and postorder iterators
    left: % -> %
@@ -11145,15 +11224,15 @@ BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with
      ++ is equivalent to \axiom{right(a)}.
    if % has shallowlyMutable then
       setelt: (%,"left",%) -> %
-	++ setelt(a,"left",b) (also written \axiom{a . left := b}) is 
-	++ equivalent to \axiom{setleft!(a,b)}.
+        ++ setelt(a,"left",b) (also written \axiom{a . left := b}) is 
+        ++ equivalent to \axiom{setleft!(a,b)}.
       setleft_!: (%,%) -> %
-	 ++ setleft!(a,b) sets the left child of \axiom{a} to be b.
+         ++ setleft!(a,b) sets the left child of \axiom{a} to be b.
       setelt: (%,"right",%) -> %
-	 ++ setelt(a,"right",b) (also written \axiom{b . right := b})
-	 ++ is equivalent to \axiom{setright!(a,b)}.
+         ++ setelt(a,"right",b) (also written \axiom{b . right := b})
+         ++ is equivalent to \axiom{setright!(a,b)}.
       setright_!: (%,%) -> %
-	 ++ setright!(a,x) sets the right child of t to be x.
+         ++ setright!(a,x) sets the right child of t to be x.
  add
    cycleMax ==> 1000
 
@@ -11186,22 +11265,22 @@ BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with
        value x = value y and left x = left y and right x = right y
      if % has finiteAggregate then
        member?(x,u) ==
-	 empty? u => false
-	 x = value u => true
-	 member?(x,left u) or member?(x,right u)
+         empty? u => false
+         x = value u => true
+         member?(x,left u) or member?(x,right u)
 
    if S has SetCategory then
      coerce(t:%): OutputForm ==
        empty? t =>  "[]"::OutputForm
        v := value(t):: OutputForm
        empty? left t =>
-	 empty? right t => v
-	 r := coerce(right t)@OutputForm
-	 bracket ["."::OutputForm, v, r]
+         empty? right t => v
+         r := coerce(right t)@OutputForm
+         bracket ["."::OutputForm, v, r]
        l := coerce(left t)@OutputForm
        r :=
-	 empty? right t => "."::OutputForm
-	 coerce(right t)@OutputForm
+         empty? right t => "."::OutputForm
+         coerce(right t)@OutputForm
        bracket [l, v, r]
 
    if % has finiteAggregate then
@@ -11216,7 +11295,7 @@ BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with
 
    isCycle?:  (%, List %) -> Boolean
    eqMember?: (%, List %) -> Boolean
-   cyclic? x	 == not empty? x and isCycle?(x,empty()$(List %))
+   cyclic? x         == not empty? x and isCycle?(x,empty()$(List %))
    isCycle?(x,acc) ==
      empty? x => false
      eqMember?(x,acc) => true
@@ -11329,13 +11408,12 @@ These exports come from \refto{AbelianMonoid}():
 ++ Keywords:
 ++ References: Davenport & Trager I
 ++ Description:
-++ This is an \spadtype{AbelianMonoid} with the cancellation property, i.e.
-++ \spad{ a+b = a+c => b=c }.
+++ This is an \spadtype{AbelianMonoid} with the cancellation property, i.e.\br
+++ \tab{5}\spad{ a+b = a+c => b=c }.\br
 ++ This is formalised by the partial subtraction operator,
-++ which satisfies the axioms listed below:
-++
-++ Axioms:
-++   \spad{c = a+b <=> c-b = a}
+++ which satisfies the  Axioms\br
+++ \tab{5}\spad{c = a+b <=> c-b = a}
+
 CancellationAbelianMonoid(): Category == AbelianMonoid with
       subtractIfCan: (%,%) -> Union(%,"failed")
          ++ subtractIfCan(x, y) returns an element z such that \spad{z+y=x}
@@ -11451,7 +11529,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{DIOPS}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -11548,6 +11626,7 @@ These exports come from \refto{Collection}(S:SetCategory)
 ++ Description:
 ++ This category is a collection of operations common to both
 ++ categories \spadtype{Dictionary} and \spadtype{MultiDictionary}
+
 DictionaryOperations(S:SetCategory): Category ==
   Join(BagAggregate S, Collection(S)) with
    dictionary: () -> %
@@ -11555,8 +11634,8 @@ DictionaryOperations(S:SetCategory): Category ==
    dictionary: List S -> %
      ++ dictionary([x,y,...,z]) creates a dictionary consisting of
      ++ entries \axiom{x,y,...,z}.
--- insert: (S,%) -> S		      ++ insert an entry
--- member?: (S,%) -> Boolean		      ++ search for an entry
+-- insert: (S,%) -> S                      ++ insert an entry
+-- member?: (S,%) -> Boolean                      ++ search for an entry
 -- remove_!: (S,%,NonNegativeInteger) -> %
 --   ++ remove!(x,d,n) destructively changes dictionary d by removing
 --   ++ up to n entries y such that \axiom{y = x}.
@@ -11580,7 +11659,7 @@ DictionaryOperations(S:SetCategory): Category ==
      copy d == dictionary parts d
      coerce(s:%):OutputForm ==
        prefix("dictionary"@String :: OutputForm,
-				      [x::OutputForm for x in parts s])
+                                      [x::OutputForm for x in parts s])
 
 @
 <<DIOPS.dotabb>>=
@@ -11695,7 +11774,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{DLAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -11778,6 +11857,7 @@ These exports come from \refto{RecursiveAggregate}(S:Type):
 ++ A doubly-linked aggregate serves as a model for a doubly-linked
 ++ list, that is, a list which can has links to both next and previous
 ++ nodes and thus can be efficiently traversed in both directions.
+
 DoublyLinkedAggregate(S:Type): Category == RecursiveAggregate S with
    last: % -> S
      ++ last(l) returns the last element of a doubly-linked aggregate l.
@@ -11793,21 +11873,21 @@ DoublyLinkedAggregate(S:Type): Category == RecursiveAggregate S with
      ++ previous(l) returns the doubly-link list beginning with its previous
      ++ element.
      ++ Error: if l has no previous element.
-     ++ Note: \axiom{next(previous(l)) = l}.
+     ++ Note that \axiom{next(previous(l)) = l}.
    next: % -> %
      ++ next(l) returns the doubly-linked aggregate beginning with its next
      ++ element.
      ++ Error: if l has no next element.
-     ++ Note: \axiom{next(l) = rest(l)} and \axiom{previous(next(l)) = l}.
+     ++ Note that \axiom{next(l) = rest(l)} and \axiom{previous(next(l)) = l}.
    if % has shallowlyMutable then
       concat_!: (%,%) -> %
-	++ concat!(u,v) destructively concatenates doubly-linked aggregate v 
+        ++ concat!(u,v) destructively concatenates doubly-linked aggregate v 
         ++ to the end of doubly-linked aggregate u.
       setprevious_!: (%,%) -> %
-	++ setprevious!(u,v) destructively sets the previous node of 
+        ++ setprevious!(u,v) destructively sets the previous node of 
         ++ doubly-linked aggregate u to v, returning v.
       setnext_!: (%,%) -> %
-	++ setnext!(u,v) destructively sets the next node of doubly-linked 
+        ++ setnext!(u,v) destructively sets the next node of doubly-linked 
         ++ aggregate u to v, returning v.
 
 @
@@ -11931,9 +12011,10 @@ These exports come from \refto{Monoid}():
 ++ The class of multiplicative groups, i.e. monoids with
 ++ multiplicative inverses.
 ++
-++ Axioms:
-++   \spad{leftInverse("*":(%,%)->%,inv)}\tab{30}\spad{ inv(x)*x = 1 }
-++   \spad{rightInverse("*":(%,%)->%,inv)}\tab{30}\spad{ x*inv(x) = 1 }
+++ Axioms\br
+++ \tab{5}\spad{leftInverse("*":(%,%)->%,inv)}\tab{5}\spad{ inv(x)*x = 1 }\br
+++ \tab{5}\spad{rightInverse("*":(%,%)->%,inv)}\tab{4}\spad{ x*inv(x) = 1 }
+
 Group(): Category == Monoid with
       inv: % -> %               
         ++ inv(x) returns the inverse of x.
@@ -12095,7 +12176,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{LNAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -12212,20 +12293,21 @@ These exports come from \refto{Collection}(S:Type):
 ++ arguments. Most of the operations exported here apply to infinite 
 ++ objects (e.g. streams) as well to finite ones.
 ++ For finite linear aggregates, see \spadtype{FiniteLinearAggregate}.
+
 LinearAggregate(S:Type): Category ==
   Join(IndexedAggregate(Integer, S), Collection(S)) with
-   new	 : (NonNegativeInteger,S) -> %
+   new         : (NonNegativeInteger,S) -> %
      ++ new(n,x) returns \axiom{fill!(new n,x)}.
    concat: (%,S) -> %
      ++ concat(u,x) returns aggregate u with additional element x at the end.
-     ++ Note: for lists, \axiom{concat(u,x) == concat(u,[x])}
+     ++ Note that for lists, \axiom{concat(u,x) == concat(u,[x])}
    concat: (S,%) -> %
      ++ concat(x,u) returns aggregate u with additional element at the front.
-     ++ Note: for lists: \axiom{concat(x,u) == concat([x],u)}.
+     ++ Note that for lists: \axiom{concat(x,u) == concat([x],u)}.
    concat: (%,%) -> %
       ++ concat(u,v) returns an aggregate consisting of the elements of u
       ++ followed by the elements of v.
-      ++ Note: if \axiom{w = concat(u,v)} then 
+      ++ Note that if \axiom{w = concat(u,v)} then 
       ++ \axiom{w.i = u.i for i in indices u}
       ++ and \axiom{w.(j + maxIndex u) = v.j for j in indices v}.
    concat: List % -> %
@@ -12233,44 +12315,44 @@ LinearAggregate(S:Type): Category ==
       ++ returns a single aggregate consisting of the elements of \axiom{a}
       ++ followed by those
       ++ of b followed ... by the elements of c.
-      ++ Note: \axiom{concat(a,b,...,c) = concat(a,concat(b,...,c))}.
+      ++ Note that \axiom{concat(a,b,...,c) = concat(a,concat(b,...,c))}.
    map: ((S,S)->S,%,%) -> %
      ++ map(f,u,v) returns a new collection w with elements 
      ++ \axiom{z = f(x,y)} for corresponding elements x and y from u and v.
-     ++ Note: for linear aggregates, \axiom{w.i = f(u.i,v.i)}.
+     ++ Note that for linear aggregates, \axiom{w.i = f(u.i,v.i)}.
    elt: (%,UniversalSegment(Integer)) -> %
       ++ elt(u,i..j) (also written: \axiom{a(i..j)}) returns the aggregate of
       ++ elements \axiom{u} for k from i to j in that order.
-      ++ Note: in general, \axiom{a.s = [a.k for i in s]}.
+      ++ Note that in general, \axiom{a.s = [a.k for i in s]}.
    delete: (%,Integer) -> %
       ++ delete(u,i) returns a copy of u with the \axiom{i}th 
-      ++ element deleted. Note: for lists, 
+      ++ element deleted. Note that for lists, 
       ++ \axiom{delete(a,i) == concat(a(0..i - 1),a(i + 1,..))}.
    delete: (%,UniversalSegment(Integer)) -> %
       ++ delete(u,i..j) returns a copy of u with the \axiom{i}th through
       ++ \axiom{j}th element deleted.
-      ++ Note: \axiom{delete(a,i..j) = concat(a(0..i-1),a(j+1..))}.
+      ++ Note that \axiom{delete(a,i..j) = concat(a(0..i-1),a(j+1..))}.
    insert: (S,%,Integer) -> %
       ++ insert(x,u,i) returns a copy of u having x as its 
       ++ \axiom{i}th element.
-      ++ Note: \axiom{insert(x,a,k) = concat(concat(a(0..k-1),x),a(k..))}.
+      ++ Note that \axiom{insert(x,a,k) = concat(concat(a(0..k-1),x),a(k..))}.
    insert: (%,%,Integer) -> %
       ++ insert(v,u,k) returns a copy of u having v inserted beginning at the
       ++ \axiom{i}th element.
-      ++ Note: \axiom{insert(v,u,k) = concat( u(0..k-1), v, u(k..) )}.
+      ++ Note that \axiom{insert(v,u,k) = concat( u(0..k-1), v, u(k..) )}.
    if % has shallowlyMutable then 
     setelt: (%,UniversalSegment(Integer),S) -> S
       ++ setelt(u,i..j,x) (also written: \axiom{u(i..j) := x}) destructively
       ++ replaces each element in the segment \axiom{u(i..j)} by x.
       ++ The value x is returned.
-      ++ Note: u is destructively change so
+      ++ Note that u is destructively change so
       ++ that \axiom{u.k := x for k in i..j};
       ++ its length remains unchanged.
  add
-  indices a	 == [i for i in minIndex a .. maxIndex a]
-  index?(i, a)	 == i >= minIndex a and i <= maxIndex a
-  concat(a:%, x:S)	== concat(a, new(1, x))
-  concat(x:S, y:%)	== concat(new(1, x), y)
+  indices a         == [i for i in minIndex a .. maxIndex a]
+  index?(i, a)         == i >= minIndex a and i <= maxIndex a
+  concat(a:%, x:S)        == concat(a, new(1, x))
+  concat(x:S, y:%)        == concat(new(1, x), y)
   insert(x:S, a:%, i:Integer) == insert(new(1, x), a, i)
   if % has finiteAggregate then
     maxIndex l == #l - 1 + minIndex l
@@ -13613,7 +13695,7 @@ should be put into these packages.
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{MATCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -13735,16 +13817,17 @@ Col:FiniteLinearAggregate(R):
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{MatrixCategory} is a general matrix category which allows
-++   different representations and indexing schemes.  Rows and
-++   columns may be extracted with rows returned as objects of
-++   type Row and colums returned as objects of type Col.
-++   A domain belonging to this category will be shallowly mutable.
-++   The index of the 'first' row may be obtained by calling the
-++   function \spadfun{minRowIndex}.  The index of the 'first' column may
-++   be obtained by calling the function \spadfun{minColIndex}.  The index of
-++   the first element of a Row is the same as the index of the
-++   first column in a matrix and vice versa.
+++ \spadtype{MatrixCategory} is a general matrix category which allows
+++ different representations and indexing schemes.  Rows and
+++ columns may be extracted with rows returned as objects of
+++ type Row and colums returned as objects of type Col.
+++ A domain belonging to this category will be shallowly mutable.
+++ The index of the 'first' row may be obtained by calling the
+++ function \spadfun{minRowIndex}.  The index of the 'first' column may
+++ be obtained by calling the function \spadfun{minColIndex}.  The index of
+++ the first element of a Row is the same as the index of the
+++ first column in a matrix and vice versa.
+
 MatrixCategory(R,Row,Col): Category == Definition where
   R   : Ring
   Row : FiniteLinearAggregate R
@@ -13814,7 +13897,7 @@ MatrixCategory(R,Row,Col): Category == Definition where
 
      diagonalMatrix: List % -> %
        ++ \spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix
-       ++ M with block matrices {\em m1},...,{\em mk} down the diagonal,
+       ++ M with block matrices m1,...,mk down the diagonal,
        ++ with 0 block matrices elsewhere.
        ++ More precisly: if \spad{ri := nrows mi}, \spad{ci := ncols mi},
        ++ then m is an (r1+..+rk) by (c1+..+ck) - matrix  with entries
@@ -14600,8 +14683,11 @@ These exports come from \refto{AbelianMonoid}():
 ++ References:
 ++ Description:
 ++ Ordered sets which are also abelian semigroups, such that the addition
-++ preserves the ordering.
-++   \spad{ x < y => x+z < y+z}
+++ preserves the ordering.\br
+++
+++ Axiom\br
+++ \tab{5} x < y => x+z < y+z
+
 OrderedAbelianSemiGroup(): Category == Join(OrderedSet, AbelianMonoid)
 
 @
@@ -14738,9 +14824,9 @@ These exports come from \refto{OrderedSet}():
 ++ Ordered sets which are also monoids, such that multiplication
 ++ preserves the ordering.
 ++
-++ Axioms:
-++   \spad{x < y => x*z < y*z}
-++   \spad{x < y => z*x < z*y}
+++ Axioms\br
+++ \tab{5}\spad{x < y => x*z < y*z}\br
+++ \tab{5}\spad{x < y => z*x < z*y}
 
 OrderedMonoid(): Category == Join(OrderedSet, Monoid)
 
@@ -14975,7 +15061,8 @@ These exports come from \refto{IntegralDomain}():
 ++ AMS Classifications:
 ++ Keywords: polynomial, multivariate, ordered variables set
 ++ References:
-++ Description: A category for finite subsets of a polynomial ring.
+++ Description:
+++ A category for finite subsets of a polynomial ring.
 ++ Such a set is only regarded as a set of polynomials and not 
 ++ identified to the ideal it generates. So two distinct sets may 
 ++ generate the same the ideal. Furthermore, for \spad{R} being an 
@@ -14984,7 +15071,6 @@ These exports come from \refto{IntegralDomain}():
 ++ or the set of its zeros (described for instance by the radical of the 
 ++ previous ideal, or a split of the associated affine variety) and so on. 
 ++ So this category provides operations about those different notions.
-++ Version: 2 
 
 PolynomialSetCategory(R:Ring, E:OrderedAbelianMonoidSup,_
   VarSet:OrderedSet, P:RecursivePolynomialCategory(R,E,VarSet)): Category == 
@@ -15457,7 +15543,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{PROAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -15525,6 +15611,7 @@ These exports come from \refto{BagAggregate}(S:OrderedSet):
 ++ Description:
 ++ A priority queue is a bag of items from an ordered set where the item
 ++ extracted is always the maximum element.
+
 PriorityQueueAggregate(S:OrderedSet): Category == BagAggregate S with
    finiteAggregate
    max: % -> S
@@ -15634,7 +15721,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{QUAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -15705,6 +15792,7 @@ These exports come from \refto{BagAggregate}(S:Type):
 ++ Description:
 ++ A queue is a bag where the first item inserted is the first 
 ++ item extracted.
+
 QueueAggregate(S:Type): Category == BagAggregate S with
    finiteAggregate
    enqueue_!: (S, %) -> S
@@ -15716,10 +15804,10 @@ QueueAggregate(S:Type): Category == BagAggregate S with
    rotate_!: % -> %
      ++ rotate! q rotates queue q so that the element at the front of
      ++ the queue goes to the back of the queue.
-     ++ Note: rotate! q is equivalent to enqueue!(dequeue!(q)).
+     ++ Note that rotate! q is equivalent to enqueue!(dequeue!(q)).
    length: % -> NonNegativeInteger
      ++ length(q) returns the number of elements in the queue.
-     ++ Note: \axiom{length(q) = #q}.
+     ++ Note that \axiom{length(q) = #q}.
    front: % -> S
      ++ front(q) returns the element at the front of the queue.
      ++ The queue q is unchanged by this operation.
@@ -15939,6 +16027,7 @@ These exports come from \refto{Collection}(S:SetCategory):
 ++ Although the operations defined for set categories are
 ++ common to both, the relationship between the two cannot
 ++ be described by inclusion or inheritance.
+
 SetAggregate(S:SetCategory):
   Category == Join(SetCategory, Collection(S)) with
    partiallyOrderedSet
@@ -15953,36 +16042,36 @@ SetAggregate(S:SetCategory):
      ++ brace([x,y,...,z]) 
      ++ creates a set aggregate containing items x,y,...,z.
      ++ This form is considered obsolete. Use \axiomFun{set} instead.
-   set	       : () -> %
+   set               : () -> %
      ++ set()$D creates an empty set aggregate of type D.
-   set	       : List S -> %
+   set               : List S -> %
      ++ set([x,y,...,z]) creates a set aggregate containing items x,y,...,z.
    intersect: (%, %) -> %
      ++ intersect(u,v) returns the set aggregate w consisting of
      ++ elements common to both set aggregates u and v.
-     ++ Note: equivalent to the notation (not currently supported)
+     ++ Note that equivalent to the notation (not currently supported)
      ++ {x for x in u | member?(x,v)}.
    difference  : (%, %) -> %
      ++ difference(u,v) returns the set aggregate w consisting of
      ++ elements in set aggregate u but not in set aggregate v.
      ++ If u and v have no elements in common, \axiom{difference(u,v)}
      ++ returns a copy of u.
-     ++ Note: equivalent to the notation (not currently supported)
+     ++ Note that equivalent to the notation (not currently supported)
      ++ \axiom{{x for x in u | not member?(x,v)}}.
    difference  : (%, S) -> %
      ++ difference(u,x) returns the set aggregate u with element x removed.
      ++ If u does not contain x, a copy of u is returned.
-     ++ Note: \axiom{difference(s, x) = difference(s, {x})}.
+     ++ Note that \axiom{difference(s, x) = difference(s, {x})}.
    symmetricDifference : (%, %) -> %
      ++ symmetricDifference(u,v) returns the set aggregate of elements x 
      ++ which are members of set aggregate u or set aggregate v but 
      ++ not both. If u and v have no elements in common, 
      ++ \axiom{symmetricDifference(u,v)} returns a copy of u.
-     ++ Note: \axiom{symmetricDifference(u,v) = 
+     ++ Note that \axiom{symmetricDifference(u,v) = 
      ++  union(difference(u,v),difference(v,u))}
    subset?     : (%, %) -> Boolean
      ++ subset?(u,v) tests if u is a subset of v.
-     ++ Note: equivalent to
+     ++ Note that equivalent to
      ++ \axiom{reduce(and,{member?(x,v) for x in u},true,false)}.
    union       : (%, %) -> %
      ++ union(u,v) returns the set aggregate of elements which are members
@@ -16106,7 +16195,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{SKAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -16174,6 +16263,7 @@ These exports come from \refto{BagAggregate}(S:Type):
 ++ References:
 ++ Description:
 ++ A stack is a bag where the last item inserted is the first item extracted.
+
 StackAggregate(S:Type): Category == BagAggregate S with
    finiteAggregate
    push_!: (S,%) -> S
@@ -16186,7 +16276,7 @@ StackAggregate(S:Type): Category == BagAggregate S with
      ++X a
    pop_!: % -> S
      ++ pop!(s) returns the top element x, destructively removing x from s.
-     ++ Note: Use \axiom{top(s)} to obtain x without removing it from s.
+     ++ Note that Use \axiom{top(s)} to obtain x without removing it from s.
      ++ Error: if s is empty.
      ++
      ++X a:Stack INT:= stack [1,2,3,4,5]
@@ -16194,13 +16284,13 @@ StackAggregate(S:Type): Category == BagAggregate S with
      ++X a
    top: % -> S
      ++ top(s) returns the top element x from s; s remains unchanged.
-     ++ Note: Use \axiom{pop!(s)} to obtain x and remove it from s.
+     ++ Note that Use \axiom{pop!(s)} to obtain x and remove it from s.
      ++
      ++X a:Stack INT:= stack [1,2,3,4,5]
      ++X top a
    depth: % -> NonNegativeInteger
      ++ depth(s) returns the number of elements of stack s.
-     ++ Note: \axiom{depth(s) = #s}.
+     ++ Note that \axiom{depth(s) = #s}.
      ++
      ++X a:Stack INT:= stack [1,2,3,4,5]
      ++X depth a
@@ -16325,7 +16415,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{URAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -16437,15 +16527,16 @@ These exports come from \refto{RecursiveAggregate}(S:Type):
 ++ of the list, and the child designating the tail, or \spadfun{rest}, 
 ++ of the list. A node with no child then designates the empty list.
 ++ Since these aggregates are recursive aggregates, they may be cyclic.
+
 UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
    concat: (%,%) -> %
       ++ concat(u,v) returns an aggregate w consisting of the elements of u
       ++ followed by the elements of v.
-      ++ Note: \axiom{v = rest(w,#a)}.
+      ++ Note that \axiom{v = rest(w,#a)}.
    concat: (S,%) -> %
       ++ concat(x,u) returns aggregate consisting of x followed by
       ++ the elements of u.
-      ++ Note: if \axiom{v = concat(x,u)} then \axiom{x = first v}
+      ++ Note that if \axiom{v = concat(x,u)} then \axiom{x = first v}
       ++ and \axiom{u = rest v}.
    first: % -> S
       ++ first(u) returns the first element of u
@@ -16465,26 +16556,26 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
       ++ equivalent to \axiom{rest u}.
    rest: (%,NonNegativeInteger) -> %
       ++ rest(u,n) returns the \axiom{n}th (n >= 0) node of u.
-      ++ Note: \axiom{rest(u,0) = u}.
+      ++ Note that \axiom{rest(u,0) = u}.
    last: % -> S
       ++ last(u) resturn the last element of u.
-      ++ Note: for lists, \axiom{last(u) = u . (maxIndex u) = u . (# u - 1)}.
+      ++ Note that for lists, \axiom{last(u)=u . (maxIndex u)=u . (# u - 1)}.
    elt: (%,"last") -> S
       ++ elt(u,"last") (also written: \axiom{u . last}) is equivalent 
       ++ to last u.
    last: (%,NonNegativeInteger) -> %
       ++ last(u,n) returns a copy of the last n (\axiom{n >= 0}) nodes of u.
-      ++ Note: \axiom{last(u,n)} is a list of n elements.
+      ++ Note that \axiom{last(u,n)} is a list of n elements.
    tail: % -> %
       ++ tail(u) returns the last node of u.
-      ++ Note: if u is \axiom{shallowlyMutable},
+      ++ Note that if u is \axiom{shallowlyMutable},
       ++ \axiom{setrest(tail(u),v) = concat(u,v)}.
    second: % -> S
       ++ second(u) returns the second element of u.
-      ++ Note: \axiom{second(u) = first(rest(u))}.
+      ++ Note that \axiom{second(u) = first(rest(u))}.
    third: % -> S
       ++ third(u) returns the third element of u.
-      ++ Note: \axiom{third(u) = first(rest(rest(u)))}.
+      ++ Note that \axiom{third(u) = first(rest(rest(u)))}.
    cycleEntry: % -> %
       ++ cycleEntry(u) returns the head of a top-level cycle contained in
       ++ aggregate u, or \axiom{empty()} if none exists.
@@ -16496,36 +16587,36 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
       ++ empty if none exists.
    if % has shallowlyMutable then
       concat_!: (%,%) -> %
-	++ concat!(u,v) destructively concatenates v to the end of u.
-	++ Note: \axiom{concat!(u,v) = setlast_!(u,v)}.
+        ++ concat!(u,v) destructively concatenates v to the end of u.
+        ++ Note that \axiom{concat!(u,v) = setlast_!(u,v)}.
       concat_!: (%,S) -> %
-	++ concat!(u,x) destructively adds element x to the end of u.
-	++ Note: \axiom{concat!(a,x) = setlast!(a,[x])}.
+        ++ concat!(u,x) destructively adds element x to the end of u.
+        ++ Note that \axiom{concat!(a,x) = setlast!(a,[x])}.
       cycleSplit_!: % -> %
-	++ cycleSplit!(u) splits the aggregate by dropping off the cycle.
-	++ The value returned is the cycle entry, or nil if none exists.
-	++ For example, if \axiom{w = concat(u,v)} is the cyclic list where 
-	++ v is the head of the cycle, \axiom{cycleSplit!(w)} will drop v 
-	++ off w thus destructively changing w to u, and returning v.
+        ++ cycleSplit!(u) splits the aggregate by dropping off the cycle.
+        ++ The value returned is the cycle entry, or nil if none exists.
+        ++ For example, if \axiom{w = concat(u,v)} is the cyclic list where 
+        ++ v is the head of the cycle, \axiom{cycleSplit!(w)} will drop v 
+        ++ off w thus destructively changing w to u, and returning v.
       setfirst_!: (%,S) -> S
-	++ setfirst!(u,x) destructively changes the first element of a to x.
+        ++ setfirst!(u,x) destructively changes the first element of a to x.
       setelt: (%,"first",S) -> S
-	++ setelt(u,"first",x) (also written: \axiom{u.first := x}) is
-	++ equivalent to \axiom{setfirst!(u,x)}.
+        ++ setelt(u,"first",x) (also written: \axiom{u.first := x}) is
+        ++ equivalent to \axiom{setfirst!(u,x)}.
       setrest_!: (%,%) -> %
-	++ setrest!(u,v) destructively changes the rest of u to v.
+        ++ setrest!(u,v) destructively changes the rest of u to v.
       setelt: (%,"rest",%) -> %
-	++ setelt(u,"rest",v) (also written: \axiom{u.rest := v}) is 
-	++ equivalent to \axiom{setrest!(u,v)}.
+        ++ setelt(u,"rest",v) (also written: \axiom{u.rest := v}) is 
+        ++ equivalent to \axiom{setrest!(u,v)}.
       setlast_!: (%,S) -> S
-	++ setlast!(u,x) destructively changes the last element of u to x.
+        ++ setlast!(u,x) destructively changes the last element of u to x.
       setelt: (%,"last",S) -> S
-	++ setelt(u,"last",x) (also written: \axiom{u.last := b})
-	++ is equivalent to \axiom{setlast!(u,v)}.
+        ++ setelt(u,"last",x) (also written: \axiom{u.last := b})
+        ++ is equivalent to \axiom{setlast!(u,v)}.
       split_!: (%,Integer) -> %
-	 ++ split!(u,n) splits u into two aggregates: \axiom{v = rest(u,n)}
-	 ++ and \axiom{w = first(u,n)}, returning \axiom{v}.
-	 ++ Note: afterwards \axiom{rest(u,n)} returns \axiom{empty()}.
+         ++ split!(u,n) splits u into two aggregates: \axiom{v = rest(u,n)}
+         ++ and \axiom{w = first(u,n)}, returning \axiom{v}.
+         ++ Note that afterwards \axiom{rest(u,n)} returns \axiom{empty()}.
  add
   cycleMax ==> 1000
 
@@ -16534,10 +16625,10 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
   elt(x, "first") == first x
   elt(x,  "last") == last x
   elt(x,  "rest") == rest x
-  second x	  == first rest x
-  third x	  == first rest rest x
-  cyclic? x	  == not empty? x and not empty? findCycle x
-  last x	  == first tail x
+  second x          == first rest x
+  third x          == first rest rest x
+  cyclic? x          == not empty? x and not empty? findCycle x
+  last x          == first tail x
 
   nodes x ==
     l := empty()$List(%)
@@ -16635,24 +16726,24 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
     x = y ==
       eq?(x, y) => true
       for k in 0.. while not empty? x and not empty? y repeat
-	k = cycleMax and cyclic? x => error "cyclic list"
-	first x ^= first y => return false
-	x := rest x
-	y := rest y
+        k = cycleMax and cyclic? x => error "cyclic list"
+        first x ^= first y => return false
+        x := rest x
+        y := rest y
       empty? x and empty? y
 
     node?(u, v) ==
       for k in 0.. while not empty? v repeat
-	u = v => return true
-	k = cycleMax and cyclic? v => error "cyclic list"
-	v := rest v
+        u = v => return true
+        k = cycleMax and cyclic? v => error "cyclic list"
+        v := rest v
       u=v
 
   if % has shallowlyMutable then
     setelt(x, "first", a) == setfirst_!(x, a)
     setelt(x,  "last", a) == setlast_!(x, a)
     setelt(x,  "rest", a) == setrest_!(x, a)
-    concat(x:%, y:%)	  == concat_!(copy x, y)
+    concat(x:%, y:%)          == concat_!(copy x, y)
 
     setlast_!(x, s) ==
       empty? x => error "setlast: empty list"
@@ -16790,10 +16881,11 @@ These exports come from \refto{CancellationAbelianMonoid}():
 ++ The class of abelian groups, i.e. additive monoids where
 ++ each element has an additive inverse.
 ++
-++ Axioms:
-++   \spad{-(-x) = x}
-++   \spad{x+(-x) = 0}
+++ Axioms\br
+++ \tab{5}\spad{-(-x) = x}\br
+++ \tab{5}\spad{x+(-x) = 0}
 -- following domain must be compiled with subsumption disabled
+
 AbelianGroup(): Category == CancellationAbelianMonoid with
       "-": % -> %                      
         ++ -x is the additive inverse of x.
@@ -16923,7 +17015,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{BTCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -16999,10 +17091,12 @@ These exports come from \refto{BinaryRecursiveAggregate}(S:SetCategory):
 ++ Keywords:
 ++ Examples:
 ++ References:
-++ Description: \spadtype{BinaryTreeCategory(S)} is the category of
+++ Description:
+++ \spadtype{BinaryTreeCategory(S)} is the category of
 ++ binary trees: a tree which is either empty or else is a 
 ++ \spadfun{node} consisting of a value and a \spadfun{left} and 
 ++ \spadfun{right}, both binary trees. 
+
 BinaryTreeCategory(S: SetCategory): Category == _
       BinaryRecursiveAggregate(S) with
    shallowlyMutable
@@ -17142,7 +17236,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{DIAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -17234,6 +17328,7 @@ These exports come from \refto{DictionaryOperations}(S:SetCategory):
 ++ This category models the usual notion of dictionary which involves
 ++ large amounts of data where copying is impractical.
 ++ Principal operations are thus destructive (non-copying) ones.
+
 Dictionary(S:SetCategory): Category ==
  DictionaryOperations S add
    dictionary l ==
@@ -17243,13 +17338,13 @@ Dictionary(S:SetCategory): Category ==
 
    if % has finiteAggregate then
     -- remove(f:S->Boolean,t:%)  == remove_!(f, copy t)
-    -- select(f, t)	   == select_!(f, copy t)
-     select_!(f, t)	 == remove_!((x:S):Boolean +-> not f(x), t)
+    -- select(f, t)           == select_!(f, copy t)
+     select_!(f, t)         == remove_!((x:S):Boolean +-> not f(x), t)
 
      --extract_! d ==
-     --	 empty? d => error "empty dictionary"
-     --	 remove_!(x := first parts d, d, 1)
-     --	 x
+     --         empty? d => error "empty dictionary"
+     --         remove_!(x := first parts d, d, 1)
+     --         x
 
      s = t ==
        eq?(s,t) => true
@@ -17379,7 +17474,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{DQAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -17470,6 +17565,7 @@ These exports come from \refto{QueueAggregate}(S:Type):
 ++ A dequeue is a doubly ended stack, that is, a bag where first items
 ++ inserted are the first items extracted, at either the front or 
 ++ the back end of the data structure.
+
 DequeueAggregate(S:Type):
  Category == Join(StackAggregate S,QueueAggregate S) with
    dequeue: () -> %
@@ -17479,7 +17575,7 @@ DequeueAggregate(S:Type):
      ++ element x, second element y,...,and last (bottom or back) element z.
    height: % -> NonNegativeInteger
      ++ height(d) returns the number of elements in dequeue d.
-     ++ Note: \axiom{height(d) = # d}.
+     ++ Note that \axiom{height(d) = # d}.
    top_!: % -> S
      ++ top!(d) returns the element at the top (front) of the dequeue.
    bottom_!: % -> S
@@ -17619,7 +17715,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{ELAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -17746,6 +17842,7 @@ These exports come from \refto{LinearAggregate}(S:Type):
 ++ concatenation efficient. However, access to elements of these
 ++ extensible aggregates is generally slow since access is made from the end.
 ++ See \spadtype{FlexibleArray} for an exception.
+
 ExtensibleLinearAggregate(S:Type):Category == LinearAggregate S with
    shallowlyMutable
    concat_!: (%,S) -> %
@@ -17784,18 +17881,18 @@ ExtensibleLinearAggregate(S:Type):Category == LinearAggregate S with
    if S has OrderedSet then merge_!: (%,%) -> %
        ++ merge!(u,v) destructively merges u and v in ascending order.
  add
-   delete(x:%, i:Integer)	   == delete_!(copy x, i)
-   delete(x:%, i:UniversalSegment(Integer))	   == delete_!(copy x, i)
+   delete(x:%, i:Integer)           == delete_!(copy x, i)
+   delete(x:%, i:UniversalSegment(Integer))           == delete_!(copy x, i)
    remove(f:S -> Boolean, x:%)   == remove_!(f, copy x)
    insert(s:S, x:%, i:Integer)   == insert_!(s, copy x, i)
    insert(w:%, x:%, i:Integer)   == insert_!(copy w, copy x, i)
-   select(f, x)		   == select_!(f, copy x)
-   concat(x:%, y:%)	   == concat_!(copy x, y)
-   concat(x:%, y:S)	   == concat_!(copy x, new(1, y))
-   concat_!(x:%, y:S)	   == concat_!(x, new(1, y))
+   select(f, x)                   == select_!(f, copy x)
+   concat(x:%, y:%)           == concat_!(copy x, y)
+   concat(x:%, y:S)           == concat_!(copy x, new(1, y))
+   concat_!(x:%, y:S)           == concat_!(x, new(1, y))
    if S has SetCategory then
-     remove(s:S, x:%)	     == remove_!(s, copy x)
-     remove_!(s:S, x:%)	     == remove_!(y +-> y = s, x)
+     remove(s:S, x:%)             == remove_!(s, copy x)
+     remove_!(s:S, x:%)             == remove_!(y +-> y = s, x)
      removeDuplicates(x:%)   == removeDuplicates_!(copy x)
 
    if S has OrderedSet then
@@ -17930,7 +18027,7 @@ is true if it is an aggregate with a finite number of elements.
 \begin{itemize}
 \item {\bf \cross{FLAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -18074,6 +18171,7 @@ These exports come from \refto{OrderedSet}:
 ++ The finite property of the aggregate adds several exports to the
 ++ list of exports from \spadtype{LinearAggregate} such as
 ++ \spadfun{reverse}, \spadfun{sort}, and so on.
+
 FiniteLinearAggregate(S:Type): Category == LinearAggregate S with
    finiteAggregate
    merge: ((S,S)->Boolean,%,%) -> %
@@ -18099,49 +18197,49 @@ FiniteLinearAggregate(S:Type): Category == LinearAggregate S with
       ++ such that \axiom{p(x)} is true, and \axiom{minIndex(a) - 1} 
       ++ if there is no such x.
    if S has SetCategory then
-      position: (S, %)	-> Integer
-	++ position(x,a) returns the index i of the first occurrence of 
-	++ x in a, and \axiom{minIndex(a) - 1} if there is no such x.
+      position: (S, %)        -> Integer
+        ++ position(x,a) returns the index i of the first occurrence of 
+        ++ x in a, and \axiom{minIndex(a) - 1} if there is no such x.
       position: (S,%,Integer) -> Integer
-	++ position(x,a,n) returns the index i of the first occurrence of 
-	++ x in \axiom{a} where \axiom{i >= n}, and \axiom{minIndex(a) - 1} 
+        ++ position(x,a,n) returns the index i of the first occurrence of 
+        ++ x in \axiom{a} where \axiom{i >= n}, and \axiom{minIndex(a) - 1} 
         ++ if no such x is found.
    if S has OrderedSet then
       OrderedSet
       merge: (%,%) -> %
-	++ merge(u,v) merges u and v in ascending order.
-	++ Note: \axiom{merge(u,v) = merge(<=,u,v)}.
+        ++ merge(u,v) merges u and v in ascending order.
+        ++ Note that \axiom{merge(u,v) = merge(<=,u,v)}.
       sort: % -> %
-	++ sort(u) returns an u with elements in ascending order.
-	++ Note: \axiom{sort(u) = sort(<=,u)}.
+        ++ sort(u) returns an u with elements in ascending order.
+        ++ Note that \axiom{sort(u) = sort(<=,u)}.
       sorted?: % -> Boolean
-	++ sorted?(u) tests if the elements of u are in ascending order.
+        ++ sorted?(u) tests if the elements of u are in ascending order.
    if % has shallowlyMutable then
       copyInto_!: (%,%,Integer) -> %
-	++ copyInto!(u,v,i) returns aggregate u containing a copy of
-	++ v inserted at element i.
+        ++ copyInto!(u,v,i) returns aggregate u containing a copy of
+        ++ v inserted at element i.
       reverse_!: % -> %
-	++ reverse!(u) returns u with its elements in reverse order.
+        ++ reverse!(u) returns u with its elements in reverse order.
       sort_!: ((S,S)->Boolean,%) -> %
-	++ sort!(p,u) returns u with its elements ordered by p.
+        ++ sort!(p,u) returns u with its elements ordered by p.
       if S has OrderedSet then sort_!: % -> %
-	++ sort!(u) returns u with its elements in ascending order.
+        ++ sort!(u) returns u with its elements in ascending order.
  add
     if S has SetCategory then
       position(x:S, t:%) == position(x, t, minIndex t)
 
     if S has OrderedSet then
---    sorted? l	  == sorted?(_<$S, l)
-      sorted? l	  == sorted?((x,y) +-> x < y or x = y, l)
+--    sorted? l          == sorted?(_<$S, l)
+      sorted? l          == sorted?((x,y) +-> x < y or x = y, l)
       merge(x, y) == merge(_<$S, x, y)
-      sort l	  == sort(_<$S, l)
+      sort l          == sort(_<$S, l)
 
     if % has shallowlyMutable then
-      reverse x	 == reverse_! copy x
+      reverse x         == reverse_! copy x
       sort(f, l) == sort_!(f, copy l)
 
       if S has OrderedSet then
-	sort_! l == sort_!(_<$S, l)
+        sort_! l == sort_!(_<$S, l)
 
 @
 <<FLAGG.dotabb>>=
@@ -18269,6 +18367,7 @@ These exports come from \refto{RetractableTo}(SetCategory):
 ++ A free abelian monoid on a set S is the monoid of finite sums of
 ++ the form \spad{reduce(+,[ni * si])} where the si's are in S, and the ni's
 ++ are in a given abelian monoid. The operation is commutative.
+
 FreeAbelianMonoidCategory(S: SetCategory, E:CancellationAbelianMonoid): _
   Category == Join(CancellationAbelianMonoid, RetractableTo S) with
         "+"        : (S, $) -> $
@@ -18428,7 +18527,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{MDAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -18518,8 +18617,9 @@ These exports come from \refto{DictionaryOperations}(S:SetCategory):
 ++ A multi-dictionary is a dictionary which may contain duplicates.
 ++ As for any dictionary, its size is assumed large so that
 ++ copying (non-destructive) operations are generally to be avoided.
+
 MultiDictionary(S:SetCategory): Category == DictionaryOperations S with
--- count: (S,%) -> NonNegativeInteger		       ++ multiplicity count
+-- count: (S,%) -> NonNegativeInteger              ++ multiplicity count
    insert_!: (S,%,NonNegativeInteger) -> %
      ++ insert!(x,d,n) destructively inserts n copies of x into dictionary d.
 -- remove_!: (S,%,NonNegativeInteger) -> %
@@ -18530,7 +18630,7 @@ MultiDictionary(S:SetCategory): Category == DictionaryOperations S with
      ++ in dictionary d.
    duplicates: % -> List Record(entry:S,count:NonNegativeInteger)
      ++ duplicates(d) returns a list of values which have duplicates in d
---   ++ duplicates(d) returns a list of		     ++ duplicates iterator
+--   ++ duplicates(d) returns a list of            ++ duplicates iterator
 -- to become duplicates: % -> Iterator(D,D)
 
 @
@@ -18645,6 +18745,7 @@ These exports come from \refto{AbelianMonoid}():
 ++ Description:
 ++ Ordered sets which are also abelian monoids, such that the addition
 ++ preserves the ordering.
+
 OrderedAbelianMonoid(): Category ==
         Join(OrderedAbelianSemiGroup, AbelianMonoid)
 
@@ -18787,35 +18888,36 @@ These exports come from \refto{OrderedSet}():
 ++ AMS Classifications:
 ++ Keywords: permutation, symmetric group
 ++ References:
-++ Description: PermutationCategory provides a categorial environment
-++  for subgroups of bijections of a set (i.e. permutations)
+++ Description:
+++ PermutationCategory provides a categorial environment
+++ for subgroups of bijections of a set (i.e. permutations)
 
 PermutationCategory(S:SetCategory): Category  ==  Group with
     cycle   :  List S       ->  %
-      ++ cycle(ls) coerces a cycle {\em ls}, i.e. a list with not
-      ++ repetitions to a permutation, which maps {\em ls.i} to
-      ++ {\em ls.i+1}, indices modulo the length of the list.
+      ++ cycle(ls) coerces a cycle ls, i.e. a list with not
+      ++ repetitions to a permutation, which maps ls.i to
+      ++ ls.i+1, indices modulo the length of the list.
       ++ Error: if repetitions occur.
     cycles  :  List List S  ->  %
-      ++ cycles(lls) coerces a list list of cycles {\em lls}
+      ++ cycles(lls) coerces a list list of cycles lls
       ++ to a permutation, each cycle being a list with not
       ++ repetitions, is coerced to the permutation, which maps
-      ++ {\em ls.i} to {\em ls.i+1}, indices modulo the length of the list,
+      ++ ls.i to ls.i+1, indices modulo the length of the list,
       ++ then these permutations are mutiplied.
       ++ Error: if repetitions occur in one cycle.
     eval  :  (%,S)          ->  S
-      ++ eval(p, el) returns the image of {\em el} under the
+      ++ eval(p, el) returns the image of el under the
       ++ permutation p.
     elt  :  (%,S)          ->  S
-      ++ elt(p, el) returns the image of {\em el} under the
+      ++ elt(p, el) returns the image of el under the
       ++ permutation p.
     orbit :  (%,S)          ->  Set S
-      ++ orbit(p, el) returns the orbit of {\em el} under the
+      ++ orbit(p, el) returns the orbit of el under the
       ++ permutation p, i.e. the set which is given by applications of
-      ++ the powers of p to {\em el}.
+      ++ the powers of p to el.
     "<" : (%,%)             ->  Boolean
       ++ p < q is an order relation on permutations.
-      ++ Note: this order is only total if and only if S is totally ordered
+      ++ Note that this order is only total if and only if S is totally ordered
       ++ or S is finite.
     if S has OrderedSet then OrderedSet
     if S has Finite then OrderedSet
@@ -18983,7 +19085,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{STAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \end{itemize}
 
@@ -19149,24 +19251,25 @@ These exports come from \refto{LinearAggregate}(S:Type):
 ++ structures such power series can be built. A stream aggregate may
 ++ also be infinite since it may be cyclic.
 ++ For example, see \spadtype{DecimalExpansion}.
+
 StreamAggregate(S:Type): Category ==
    Join(UnaryRecursiveAggregate S, LinearAggregate S) with
       explicitlyFinite?: % -> Boolean
-	++ explicitlyFinite?(s) tests if the stream has a finite
-	++ number of elements, and false otherwise.
-	++ Note: for many datatypes, 
+        ++ explicitlyFinite?(s) tests if the stream has a finite
+        ++ number of elements, and false otherwise.
+        ++ Note that for many datatypes, 
         ++ \axiom{explicitlyFinite?(s) = not possiblyInfinite?(s)}.
       possiblyInfinite?: % -> Boolean
-	++ possiblyInfinite?(s) tests if the stream s could possibly
-	++ have an infinite number of elements.
-	++ Note: for many datatypes, 
+        ++ possiblyInfinite?(s) tests if the stream s could possibly
+        ++ have an infinite number of elements.
+        ++ Note that for many datatypes, 
         ++ \axiom{possiblyInfinite?(s) = not explictlyFinite?(s)}.
  add
    c2: (%, %) -> S
 
    explicitlyFinite? x == not cyclic? x
    possiblyInfinite? x == cyclic? x
-   first(x, n)	       == construct [c2(x, x := rest x) for i in 1..n]
+   first(x, n)               == construct [c2(x, x := rest x) for i in 1..n]
 
    c2(x, r) ==
      empty? x => error "Index out of range"
@@ -19195,8 +19298,8 @@ StreamAggregate(S:Type): Category ==
      map_!(f, l) ==
        y := l
        while not empty? l repeat
-	 setfirst_!(l, f first l)
-	 l := rest l
+         setfirst_!(l, f first l)
+         l := rest l
        y
 
      fill_!(x, s) ==
@@ -19371,7 +19474,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{TSETCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{TSETCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -19510,6 +19613,9 @@ V:OrderedSet, P:RecursivePolynomialCategory(R,E,V)):
 ++ Also See: 
 ++ AMS Classifications:
 ++ Keywords: polynomial, multivariate, ordered variables set
+++ References :
+++  [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories
+++      of Triangular Sets" Journal of Symbol. Comp. (to appear)
 ++ Description:
 ++ The category of triangular sets of multivariate polynomials
 ++ with coefficients in an integral domain.
@@ -19527,11 +19633,7 @@ V:OrderedSet, P:RecursivePolynomialCategory(R,E,V)):
 ++ \axiom{Q} if the degree of \axiom{P} in the main variable of \axiom{Q} 
 ++ is less than the main degree of \axiom{Q}.
 ++ A polynomial \axiom{P} is reduced w.r.t a triangular set \axiom{T}
-++ if it is reduced w.r.t. every polynomial of \axiom{T}. \newline
-++ References :
-++  [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories
-++      of Triangular Sets" Journal of Symbol. Comp. (to appear)
-++ Version: 4.
+++ if it is reduced w.r.t. every polynomial of \axiom{T}. 
 
 TriangularSetCategory(R:IntegralDomain,E:OrderedAbelianMonoidSup,_
  V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): 
@@ -20164,12 +20266,12 @@ These exports come from \refto{AbelianGroup}():
 ++ Author: Manuel Bronstein
 ++ Date Created: 19 May 1993
 ++ Date Last Updated: 19 May 1993
+++ Keywords: divisor, algebraic, curve.
 ++ Description:
 ++ This category describes finite rational divisors on a curve, that
 ++ is finite formal sums SUM(n * P) where the n's are integers and the
 ++ P's are finite rational points on the curve.
-++ Keywords: divisor, algebraic, curve.
-++ Examples: )r FDIV INPUT
+
 FiniteDivisorCategory(F, UP, UPUP, R): Category == Result where
   F   : Field
   UP  : UnivariatePolynomialCategory F
@@ -20333,7 +20435,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{FSAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{FSAGG}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -20466,32 +20568,33 @@ These exports come from \refto{SetAggregate}(S:SetCategory):
 ++ a collection of elements characterized by membership, but not
 ++ by order or multiplicity.
 ++ See \spadtype{Set} for an example.
+
 FiniteSetAggregate(S:SetCategory): Category ==
   Join(Dictionary S, SetAggregate S) with
     finiteAggregate
     cardinality: % -> NonNegativeInteger
       ++ cardinality(u) returns the number of elements of u.
-      ++ Note: \axiom{cardinality(u) = #u}.
+      ++ Note that \axiom{cardinality(u) = #u}.
     if S has Finite then
       Finite
       complement: % -> %
-	++ complement(u) returns the complement of the set u,
-	++ i.e. the set of all values not in u.
+        ++ complement(u) returns the complement of the set u,
+        ++ i.e. the set of all values not in u.
       universe: () -> %
-	++ universe()$D returns the universal set for finite set aggregate D.
+        ++ universe()$D returns the universal set for finite set aggregate D.
     if S has OrderedSet then
       max: % -> S
-	++ max(u) returns the largest element of aggregate u.
+        ++ max(u) returns the largest element of aggregate u.
       min: % -> S
-	++ min(u) returns the smallest element of aggregate u.
+        ++ min(u) returns the smallest element of aggregate u.
 
  add
-   s < t	   == #s < #t and s = intersect(s,t)
-   s = t	   == #s = #t and empty? difference(s,t)
-   brace l	   == construct l
-   set	 l	   == construct l
+   s < t           == #s < #t and s = intersect(s,t)
+   s = t           == #s = #t and empty? difference(s,t)
+   brace l           == construct l
+   set         l           == construct l
    cardinality s   == #s
-   construct l	   == (s := set(); for x in l repeat insert_!(x,s); s)
+   construct l           == (s := set(); for x in l repeat insert_!(x,s); s)
    count(x:S, s:%) == (member?(x, s) => 1; 0)
    subset?(s, t)   == #s < #t and _and/[member?(x, t) for x in parts s]
 
@@ -20520,7 +20623,7 @@ FiniteSetAggregate(S:SetCategory): Category ==
       u
 
    if S has Finite then
-     universe()	  == {index(i::PositiveInteger) for i in 1..size()$S}
+     universe()          == {index(i::PositiveInteger) for i in 1..size()$S}
      complement s == difference(universe(), s )
      size()  == 2 ** size()$S
      index i ==
@@ -20645,7 +20748,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{KDAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -20755,6 +20858,7 @@ and S=Record(key: Key,entry: Entry)
 ++ Description:
 ++ A keyed dictionary is a dictionary of key-entry pairs for which there is
 ++ a unique entry for each key.
+
 KeyedDictionary(Key:SetCategory, Entry:SetCategory): Category ==
   Dictionary Record(key:Key,entry:Entry) with
    key?: (Key, %) -> Boolean
@@ -21097,7 +21201,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
   remove: (S -> Boolean,%) -> %
     ++ remove(f,st) returns a stream consisting of those elements of stream
     ++ st which do not satisfy the predicate f.
-    ++ Note: \spad{remove(f,st) = [x for x in st | not f(x)]}.
+    ++ Note that \spad{remove(f,st) = [x for x in st | not f(x)]}.
     ++
     ++X m:=[i for i in 1..]
     ++X f(i:PositiveInteger):Boolean == even? i
@@ -21106,7 +21210,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
   select: (S -> Boolean,%) -> %
     ++ select(f,st) returns a stream consisting of those elements of stream
     ++ st satisfying the predicate f.
-    ++ Note: \spad{select(f,st) = [x for x in st | f(x)]}.
+    ++ Note that \spad{select(f,st) = [x for x in st | f(x)]}.
     ++
     ++X m:=[i for i in 0..]
     ++X select(x+->prime? x,m)
@@ -21121,7 +21225,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
   explicitlyEmpty?: % -> Boolean
     ++ explicitlyEmpty?(s) returns true if the stream is an
     ++ (explicitly) empty stream.
-    ++ Note: this is a null test which will not cause lazy evaluation.
+    ++ Note that this is a null test which will not cause lazy evaluation.
     ++
     ++X m:=[i for i in 0..]
     ++X explicitlyEmpty? m
@@ -21138,7 +21242,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
     ++ lazyEvaluate(s) causes one lazy evaluation of stream s.
     ++ Caution: the first node must be a lazy evaluation mechanism
     ++ (satisfies \spad{lazy?(s) = true}) as there is no error check.
-    ++ Note: a call to this function may
+    ++ Note that a call to this function may
     ++ or may not produce an explicit first entry
   frst: % -> S
     ++ frst(s) returns the first element of stream s.
@@ -21717,10 +21821,11 @@ These exports come from \refto{AbelianGroup}():
 ++ This is an abelian group which supports left multiplation by elements of
 ++ the rng.
 ++
-++ Axioms:
-++   \spad{ (a*b)*x = a*(b*x) }
-++   \spad{ (a+b)*x = (a*x)+(b*x) }
-++   \spad{ a*(x+y) = (a*x)+(a*y) }
+++ Axioms\br
+++ \tab{5}\spad{ (a*b)*x = a*(b*x) }\br
+++ \tab{5}\spad{ (a+b)*x = (a*x)+(b*x) }\br
+++ \tab{5}\spad{ a*(x+y) = (a*x)+(a*y) }
+
 LeftModule(R:Rng):Category == AbelianGroup with
    "*": (R,%) -> %     
      ++ r*x returns the left multiplication of the module element x
@@ -21890,7 +21995,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{LSAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -22088,22 +22193,23 @@ These exports come from \refto{ExtensibleLinearAggregate}(S:Type):
 ++ A linked list is a versatile
 ++ data structure. Insertion and deletion are efficient and
 ++ searching is a linear operation.
+
 ListAggregate(S:Type): Category == Join(StreamAggregate S,
    FiniteLinearAggregate S, ExtensibleLinearAggregate S) with
       list: S -> %
-	++ list(x) returns the list of one element x.
+        ++ list(x) returns the list of one element x.
  add
    cycleMax ==> 1000
 
    mergeSort: ((S, S) -> Boolean, %, Integer) -> %
 
-   sort_!(f, l)	      == mergeSort(f, l, #l)
-   list x		   == concat(x, empty())
-   reduce(f, x)		   ==
+   sort_!(f, l)              == mergeSort(f, l, #l)
+   list x                   == concat(x, empty())
+   reduce(f, x)                   ==
      empty? x => _
        error "reducing over an empty list needs the 3 argument form"
      reduce(f, rest x, first x)
-   merge(f, p, q)	   == merge_!(f, copy p, copy q)
+   merge(f, p, q)           == merge_!(f, copy p, copy q)
 
    select_!(f, x) ==
      while not empty? x and not f first x repeat x := rest x
@@ -22112,7 +22218,7 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S,
      z := rest y
      while not empty? z repeat
        if f first z then (y := z; z := rest z)
-		    else (z := rest z; setrest_!(y, z))
+                    else (z := rest z; setrest_!(y, z))
      x
 
    merge_!(f, p, q) ==
@@ -22124,8 +22230,8 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S,
        else (r := t := q; q := rest q)
      while not empty? p and not empty? q repeat
        if f(first p, first q)
-	 then (setrest_!(t, p); t := p; p := rest p)
-	 else (setrest_!(t, q); t := q; q := rest q)
+         then (setrest_!(t, p); t := p; p := rest p)
+         else (setrest_!(t, q); t := q; q := rest q)
      setrest_!(t, if empty? p then q else p)
      r
 
@@ -22153,7 +22259,7 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S,
      q := rest x
      while not empty? q repeat
        if f first q then q := setrest_!(p, rest q)
-		    else (p := q; q := rest q)
+                    else (p := q; q := rest q)
      x
 
    delete_!(x:%, i:Integer) ==
@@ -22207,11 +22313,11 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S,
 
    if S has SetCategory then
       reduce(f, x, i,a) ==
-	r := i
-	while not empty? x and r ^= a repeat
-	  r := f(r, first x)
-	  x := rest x
-	r
+        r := i
+        while not empty? x and r ^= a repeat
+          r := f(r, first x)
+          x := rest x
+        r
 
    new(n, s) ==
      l := empty()
@@ -22234,9 +22340,9 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S,
 --     y := rest y
 --   z := reverseInPlace z
 --   if not empty? x then
---	z := concat_!(z, map(f(#1, d), x))
+--        z := concat_!(z, map(f(#1, d), x))
 --   if not empty? y then
---	z := concat_!(z, map(f(d, #1), y))
+--        z := concat_!(z, map(f(d, #1), y))
 --   z
 
    reverse_! x ==
@@ -22272,24 +22378,24 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S,
        s < (m := minIndex x) => error "index out of range"
        x := rest(x, (s - m)::NonNegativeInteger)
        for k in s.. while not empty? x and w ^= first x repeat
-	 x := rest x
+         x := rest x
        empty? x => minIndex x - 1
        k
 
      removeDuplicates_! l ==
        p := l
        while not empty? p repeat
-	 p := setrest_!(p, remove_!((x:S):Boolean +-> x = first p, rest p))
+         p := setrest_!(p, remove_!((x:S):Boolean +-> x = first p, rest p))
        l
 
    if S has OrderedSet then
      x < y ==
-	while not empty? x and not empty? y repeat
-	  first x ^= first y => return(first x < first y)
-	  x := rest x
-	  y := rest y
-	empty? x => not empty? y
-	false
+        while not empty? x and not empty? y repeat
+          first x ^= first y => return(first x < first y)
+          x := rest x
+          y := rest y
+        empty? x => not empty? y
+        false
 
 @
 <<LSAGG.dotabb>>=
@@ -22412,7 +22518,7 @@ is true if a set with $<$ which is transitive, but
 not($a < b$ or $a = b$) does not necessarily imply $b<a$.
 \item {\bf \cross{MSETAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -22513,6 +22619,7 @@ These exports come from \refto{SetAggregate}(S:SetCategory):
 ++ Description:
 ++ A multi-set aggregate is a set which keeps track of the multiplicity
 ++ of its elements.
+
 MultisetAggregate(S:SetCategory):
  Category == Join(MultiDictionary S, SetAggregate S)
 
@@ -22639,13 +22746,15 @@ These exports come from \refto{Monad}():
 ++  R.D. Schafer: An Introduction to Nonassociative Algebras
 ++  Academic Press, New York, 1966
 ++ Description:
-++  NonAssociativeRng is a basic ring-type structure, not necessarily
-++  commutative or associative, and not necessarily with unit.
-++  Axioms
-++    x*(y+z) = x*y + x*z
-++    (x+y)*z = x*z + y*z
-++  Common Additional Axioms
-++    noZeroDivisors  ab = 0 => a=0 or b=0
+++ NonAssociativeRng is a basic ring-type structure, not necessarily
+++ commutative or associative, and not necessarily with unit.\br
+++ Axioms\br
+++ \tab{5}x*(y+z) = x*y + x*z\br
+++ \tab{5}(x+y)*z = x*z + y*z\br
+++
+++ Common Additional Axioms\br
+++ \tab{5}noZeroDivisors\tab{5} ab = 0 => a=0 or b=0
+
 NonAssociativeRng(): Category == Join(AbelianGroup,Monad)  with
     associator: (%,%,%) -> %
       ++ associator(a,b,c) returns \spad{(a*b)*c-a*(b*c)}.
@@ -22789,7 +22898,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{A1AGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -22933,41 +23042,42 @@ These exports come from \refto{FiniteLinearAggregate}(S:Type):
 ++ (and often can be optimized to open-code).
 ++ Insertion and deletion however is generally slow since an entirely new
 ++ data structure must be created for the result.
+
 OneDimensionalArrayAggregate(S:Type): Category ==
     FiniteLinearAggregate S with shallowlyMutable
   add
-    parts x	    == [qelt(x, i) for i in minIndex x .. maxIndex x]
+    parts x            == [qelt(x, i) for i in minIndex x .. maxIndex x]
     sort_!(f, a) == quickSort(f, a)$FiniteLinearAggregateSort(S, %)
 
     any?(f, a) ==
       for i in minIndex a .. maxIndex a repeat
-	f qelt(a, i) => return true
+        f qelt(a, i) => return true
       false
 
     every?(f, a) ==
       for i in minIndex a .. maxIndex a repeat
-	not(f qelt(a, i)) => return false
+        not(f qelt(a, i)) => return false
       true
 
     position(f:S -> Boolean, a:%) ==
       for i in minIndex a .. maxIndex a repeat
-	f qelt(a, i) => return i
+        f qelt(a, i) => return i
       minIndex(a) - 1
 
     find(f, a) ==
       for i in minIndex a .. maxIndex a repeat
-	f qelt(a, i) => return qelt(a, i)
+        f qelt(a, i) => return qelt(a, i)
       "failed"
 
     count(f:S->Boolean, a:%) ==
       n:NonNegativeInteger := 0
       for i in minIndex a .. maxIndex a repeat
-	if f(qelt(a, i)) then n := n+1
+        if f(qelt(a, i)) then n := n+1
       n
 
     map_!(f, a) ==
       for i in minIndex a .. maxIndex a repeat
-	qsetelt_!(a, i, f qelt(a, i))
+        qsetelt_!(a, i, f qelt(a, i))
       a
 
     setelt(a:%, s:UniversalSegment(Integer), x:S) ==
@@ -22984,14 +23094,14 @@ OneDimensionalArrayAggregate(S:Type): Category ==
 
     reduce(f, a, identity) ==
       for k in minIndex a .. maxIndex a repeat
-	identity := f(identity, qelt(a, k))
+        identity := f(identity, qelt(a, k))
       identity
 
     if S has SetCategory then
        reduce(f, a, identity,absorber) ==
-	 for k in minIndex a .. maxIndex a while identity ^= absorber
-		repeat identity := f(identity, qelt(a, k))
-	 identity
+         for k in minIndex a .. maxIndex a while identity ^= absorber
+                repeat identity := f(identity, qelt(a, k))
+         identity
 
 -- this is necessary since new has disappeared.
     stupidnew: (NonNegativeInteger, %, %) -> %
@@ -23003,7 +23113,7 @@ OneDimensionalArrayAggregate(S:Type): Category ==
 -- at least one element of l must be non-empty
     stupidget l ==
       for a in l repeat
-	not empty? a => return first a
+        not empty? a => return first a
       error "Should not happen"
 
     map(f, a, b) ==
@@ -23012,7 +23122,7 @@ OneDimensionalArrayAggregate(S:Type): Category ==
       l := max(0, n - m + 1)::NonNegativeInteger
       c := stupidnew(l, a, b)
       for i in minIndex(c).. for j in m..n repeat
-	qsetelt_!(c, i, f(qelt(a, j), qelt(b, j)))
+        qsetelt_!(c, i, f(qelt(a, j), qelt(b, j)))
       c
 
 --  map(f, a, b, x) ==
@@ -23021,7 +23131,7 @@ OneDimensionalArrayAggregate(S:Type): Category ==
 --    l := (n - m + 1)::NonNegativeInteger
 --    c := new l
 --    for i in minIndex(c).. for j in m..n repeat
---	qsetelt_!(c, i, f(a(j, x), b(j, x)))
+--        qsetelt_!(c, i, f(a(j, x), b(j, x)))
 --    c
 
     merge(f, a, b) ==
@@ -23031,12 +23141,12 @@ OneDimensionalArrayAggregate(S:Type): Category ==
       j := minIndex b
       n := maxIndex b
       for k in minIndex(r).. while i <= m and j <= n repeat
-	if f(qelt(a, i), qelt(b, j)) then
-	  qsetelt_!(r, k, qelt(a, i))
-	  i := i+1
-	else
-	  qsetelt_!(r, k, qelt(b, j))
-	  j := j+1
+        if f(qelt(a, i), qelt(b, j)) then
+          qsetelt_!(r, k, qelt(a, i))
+          i := i+1
+        else
+          qsetelt_!(r, k, qelt(b, j))
+          j := j+1
       for k in k.. for i in i..m repeat qsetelt_!(r, k, elt(a, i))
       for k in k.. for j in j..n repeat qsetelt_!(r, k, elt(b, j))
       r
@@ -23047,7 +23157,7 @@ OneDimensionalArrayAggregate(S:Type): Category ==
       l < minIndex a or h > maxIndex a => error "index out of range"
       r := stupidnew(max(0, h - l + 1)::NonNegativeInteger, a, a)
       for k in minIndex r.. for i in l..h repeat
-	qsetelt_!(r, k, qelt(a, i))
+        qsetelt_!(r, k, qelt(a, i))
       r
 
     insert(a:%, b:%, i:Integer) ==
@@ -23056,23 +23166,23 @@ OneDimensionalArrayAggregate(S:Type): Category ==
       i < m or i > n => error "index out of range"
       y := stupidnew(#a + #b, a, b)
       for k in minIndex y.. for j in m..i-1 repeat
-	qsetelt_!(y, k, qelt(b, j))
+        qsetelt_!(y, k, qelt(b, j))
       for k in k.. for j in minIndex a .. maxIndex a repeat
-	qsetelt_!(y, k, qelt(a, j))
+        qsetelt_!(y, k, qelt(a, j))
       for k in k.. for j in i..n repeat qsetelt_!(y, k, qelt(b, j))
       y
 
     copy x ==
       y := stupidnew(#x, x, x)
       for i in minIndex x .. maxIndex x for j in minIndex y .. repeat
-	qsetelt_!(y, j, qelt(x, i))
+        qsetelt_!(y, j, qelt(x, i))
       y
 
     copyInto_!(y, x, s) ==
       s < minIndex y or s + #x > maxIndex y + 1 =>
-					      error "index out of range"
+                                              error "index out of range"
       for i in minIndex x .. maxIndex x for j in s.. repeat
-	qsetelt_!(y, j, qelt(x, i))
+        qsetelt_!(y, j, qelt(x, i))
       y
 
     construct l ==
@@ -23088,18 +23198,18 @@ OneDimensionalArrayAggregate(S:Type): Category ==
       h < l => copy a
       r := stupidnew((#a - h + l - 1)::NonNegativeInteger, a, a)
       for k in minIndex(r).. for i in minIndex a..l-1 repeat
-	qsetelt_!(r, k, qelt(a, i))
+        qsetelt_!(r, k, qelt(a, i))
       for k in k.. for i in h+1 .. maxIndex a repeat
-	qsetelt_!(r, k, qelt(a, i))
+        qsetelt_!(r, k, qelt(a, i))
       r
 
     delete(x:%, i:Integer) ==
       i < minIndex x or i > maxIndex x => error "index out of range"
       y := stupidnew((#x - 1)::NonNegativeInteger, x, x)
       for i in minIndex(y).. for j in minIndex x..i-1 repeat
-	qsetelt_!(y, i, qelt(x, j))
+        qsetelt_!(y, i, qelt(x, j))
       for i in i .. for j in i+1 .. maxIndex x repeat
-	qsetelt_!(y, i, qelt(x, j))
+        qsetelt_!(y, i, qelt(x, j))
       y
 
     reverse_! x ==
@@ -23113,13 +23223,13 @@ OneDimensionalArrayAggregate(S:Type): Category ==
       n := _+/[#a for a in l]
       i := minIndex(r := new(n, stupidget l))
       for a in l repeat
-	copyInto_!(r, a, i)
-	i := i + #a
+        copyInto_!(r, a, i)
+        i := i + #a
       r
 
     sorted?(f, a) ==
       for i in minIndex(a)..maxIndex(a)-1 repeat
-	not f(qelt(a, i), qelt(a, i + 1)) => return false
+        not f(qelt(a, i), qelt(a, i + 1)) => return false
       true
 
     concat(x:%, y:%) ==
@@ -23130,28 +23240,28 @@ OneDimensionalArrayAggregate(S:Type): Category ==
 
     if S has SetCategory then
       x = y ==
-	#x ^= #y => false
-	for i in minIndex x .. maxIndex x repeat
-	  not(qelt(x, i) = qelt(y, i)) => return false
-	true
+        #x ^= #y => false
+        for i in minIndex x .. maxIndex x repeat
+          not(qelt(x, i) = qelt(y, i)) => return false
+        true
 
       coerce(r:%):OutputForm ==
-	bracket commaSeparate
-	      [qelt(r, k)::OutputForm for k in minIndex r .. maxIndex r]
+        bracket commaSeparate
+              [qelt(r, k)::OutputForm for k in minIndex r .. maxIndex r]
 
       position(x:S, t:%, s:Integer) ==
-	n := maxIndex t
-	s < minIndex t or s > n => error "index out of range"
-	for k in s..n repeat
-	  qelt(t, k) = x => return k
-	minIndex(t) - 1
+        n := maxIndex t
+        s < minIndex t or s > n => error "index out of range"
+        for k in s..n repeat
+          qelt(t, k) = x => return k
+        minIndex(t) - 1
 
     if S has OrderedSet then
       a < b ==
-	for i in minIndex a .. maxIndex a
-	  for j in minIndex b .. maxIndex b repeat
-	    qelt(a, i) ^= qelt(b, j) => return a.i < b.j
-	#a < #b
+        for i in minIndex a .. maxIndex a
+          for j in minIndex b .. maxIndex b repeat
+            qelt(a, i) ^= qelt(b, j) => return a.i < b.j
+        #a < #b
 
 
 @
@@ -23273,6 +23383,7 @@ These exports come from \refto{CancellationAbelianMonoid}():
 ++ Description:
 ++ Ordered sets which are also abelian cancellation monoids, 
 ++ such that the addition preserves the ordering.
+
 OrderedCancellationAbelianMonoid(): Category ==
         Join(OrderedAbelianMonoid, CancellationAbelianMonoid)
 
@@ -23430,7 +23541,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{RSETCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{RSETCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -23592,6 +23703,15 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++ Also See: essai Graphisme
 ++ AMS Classifications:
 ++ Keywords: polynomial, multivariate, ordered variables set
+++ References :
+++  [1] M. KALKBRENER "Three contributions to elimination theory"
+++      Phd Thesis, University of Linz, Austria, 1991.
+++  [2] M. KALKBRENER "Algorithmic properties of polynomial rings"
+++      Journal of Symbol. Comp. 1998
+++  [3] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories
+++      of Triangular Sets" Journal of Symbol. Comp. (to appear)
+++  [4] M. MORENO MAZA "A new algorithm for computing triangular
+++      decomposition of algebraic varieties" NAG Tech. Rep. 4/98.
 ++ Description:
 ++ The category of regular triangular sets, introduced under
 ++ the name regular chains in [1] (and other papers).
@@ -23629,18 +23749,8 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++ This category provides operations related to both kinds of
 ++ splits, the former being related to ideals decomposition whereas 
 ++ the latter deals with varieties decomposition.
-++ See the example illustrating the \spadtype{RegularTriangularSet} constructor
-++ for more explanations about decompositions by means of regular triangular sets. \newline
-++ References :
-++  [1] M. KALKBRENER "Three contributions to elimination theory"
-++      Phd Thesis, University of Linz, Austria, 1991.
-++  [2] M. KALKBRENER "Algorithmic properties of polynomial rings"
-++      Journal of Symbol. Comp. 1998
-++  [3] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories
-++      of Triangular Sets" Journal of Symbol. Comp. (to appear)
-++  [4] M. MORENO MAZA "A new algorithm for computing triangular
-++      decomposition of algebraic varieties" NAG Tech. Rep. 4/98.
-++ Version: 2
+++ See the example illustrating the RegularTriangularSet constructor for more 
+++ explanations about decompositions by means of regular triangular sets. 
 
 RegularTriangularSetCategory(R:GcdDomain, E:OrderedAbelianMonoidSup,_
   V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)):
@@ -23660,9 +23770,9 @@ RegularTriangularSetCategory(R:GcdDomain, E:OrderedAbelianMonoidSup,_
       ++ \spad{purelyAlgebraic?(ts)} returns true iff for every algebraic 
       ++ variable \spad{v} of \spad{ts} we have 
       ++ \spad{algebraicCoefficients?(t_v,ts_v_-)} where \spad{ts_v}
-      ++ is \axiomOpFrom{select}{TriangularSetCategory}(ts,v) and 
+      ++ is select from TriangularSetCategory(ts,v) and 
       ++ \spad{ts_v_-} is 
-      ++ \axiomOpFrom{collectUnder}{TriangularSetCategory}(ts,v).
+      ++ collectUnder from TriangularSetCategory(ts,v).
     purelyAlgebraicLeadingMonomial?: (P, $) -> Boolean
       ++ \spad{purelyAlgebraicLeadingMonomial?(p,ts)} returns true iff
       ++ the main variable of any non-constant iterarted initial 
@@ -24047,10 +24157,11 @@ These exports come from \refto{AbelianGroup}():
 ++ with unit). This is an abelian group which supports right 
 ++ multiplication by elements of the rng.
 ++
-++ Axioms:
-++   \spad{ x*(a*b) = (x*a)*b }
-++   \spad{ x*(a+b) = (x*a)+(x*b) }
-++   \spad{ (x+y)*x = (x*a)+(y*a) }
+++ Axioms\br
+++ \tab{5}\spad{ x*(a*b) = (x*a)*b }\br
+++ \tab{5}\spad{ x*(a+b) = (x*a)+(x*b) }\br
+++ \tab{5}\spad{ (x+y)*x = (x*a)+(y*a) }
+
 RightModule(R:Rng):Category == AbelianGroup with
    "*": (%,R) -> %  
      ++ x*r returns the right multiplication of the module element x
@@ -24166,12 +24277,13 @@ These exports come from \refto{SemiGroup}():
 ++ necessarily with a 1. This is a combination of an abelian group
 ++ and a semigroup, with multiplication distributing over addition.
 ++
-++ Axioms:
-++   \spad{ x*(y+z) = x*y + x*z}
-++   \spad{ (x+y)*z = x*z + y*z }
+++ Axioms\br
+++ \tab{5}\spad{ x*(y+z) = x*y + x*z}\br
+++ \tab{5}\spad{ (x+y)*z = x*z + y*z }
 ++
-++ Conditional attributes:
-++   \spadnoZeroDivisors\tab{25}\spad{  ab = 0 => a=0 or b=0}
+++ Conditional attributes\br
+++ \tab{5}noZeroDivisors\tab{5}\spad{  ab = 0 => a=0 or b=0}
+
 Rng(): Category == Join(AbelianGroup,SemiGroup)
 
 @ 
@@ -24306,8 +24418,9 @@ These exports come from \refto{RightModule}(S:Ring):
 ++ A \spadtype{BiModule} is both a left and right module with respect
 ++ to potentially different rings.
 ++
-++ Axiom:
-++   \spad{ r*(x*s) = (r*x)*s }
+++ Axiom\br
+++ \tab{5}\spad{ r*(x*s) = (r*x)*s }
+
 BiModule(R:Ring,S:Ring):Category ==
   Join(LeftModule(R),RightModule(S)) with
      leftUnitary 
@@ -24461,7 +24574,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{BTAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{BTAGG}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -24623,33 +24736,34 @@ These exports come from \refto{OneDimensionalArrayAggregate}(Boolean):
 ++ Description:
 ++ The bit aggregate category models aggregates representing large
 ++ quantities of Boolean data.
+
 BitAggregate(): Category ==
   Join(OrderedSet, Logic, OneDimensionalArrayAggregate Boolean) with
     "not": % -> %
-      ++ not(b) returns the logical {\em not} of bit aggregate 
+      ++ not(b) returns the logical not of bit aggregate 
       ++ \axiom{b}.
     "^"  : % -> %
-      ++ ^ b returns the logical {\em not} of bit aggregate 
+      ++ ^ b returns the logical not of bit aggregate 
       ++ \axiom{b}.
     nand : (%, %) -> %
-      ++ nand(a,b) returns the logical {\em nand} of bit aggregates 
+      ++ nand(a,b) returns the logical nand of bit aggregates 
       ++ \axiom{a} and \axiom{b}.
-    nor	 : (%, %) -> %
-      ++ nor(a,b) returns the logical {\em nor} of bit aggregates 
+    nor         : (%, %) -> %
+      ++ nor(a,b) returns the logical nor of bit aggregates 
       ++ \axiom{a} and \axiom{b}.
     _and : (%, %) -> %
-      ++ a and b returns the logical {\em and} of bit aggregates 
+      ++ a and b returns the logical and of bit aggregates 
       ++ \axiom{a} and \axiom{b}.
-    _or	 : (%, %) -> %
-      ++ a or b returns the logical {\em or} of bit aggregates 
+    _or         : (%, %) -> %
+      ++ a or b returns the logical or of bit aggregates 
       ++ \axiom{a} and \axiom{b}.
-    xor	 : (%, %) -> %
-      ++ xor(a,b) returns the logical {\em exclusive-or} of bit aggregates
+    xor         : (%, %) -> %
+      ++ xor(a,b) returns the logical exclusive-or of bit aggregates
       ++ \axiom{a} and \axiom{b}.
 
  add
    not v      == map(_not, v)
-   _^ v	      == map(_not, v)
+   _^ v              == map(_not, v)
    _~(v)      == map(_~, v)
    _/_\(v, u) == map(_/_\, v, u)
    _\_/(v, u) == map(_\_/, v, u)
@@ -24824,8 +24938,9 @@ These exports come from \refto{MonadWithUnit}():
 ++  R.D. Schafer: An Introduction to Nonassociative Algebras
 ++  Academic Press, New York, 1966
 ++ Description:
-++  A NonAssociativeRing is a non associative rng which has a unit,
-++  the multiplication is not necessarily commutative or associative.
+++ A NonAssociativeRing is a non associative rng which has a unit,
+++ the multiplication is not necessarily commutative or associative.
+
 NonAssociativeRing(): Category == Join(NonAssociativeRng,MonadWithUnit) with
       characteristic: -> NonNegativeInteger
         ++ characteristic() returns the characteristic of the ring.
@@ -25000,7 +25115,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{NTSCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{NTSCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -25155,15 +25270,6 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++ Also See: essai Graphisme
 ++ AMS Classifications:
 ++ Keywords: polynomial, multivariate, ordered variables set
-++ Description:
-++ The category of normalized triangular sets. A triangular
-++ set \spad{ts} is said normalized if for every algebraic
-++ variable \spad{v} of \spad{ts} the polynomial \spad{select(ts,v)}
-++ is normalized w.r.t. every polynomial in \spad{collectUnder(ts,v)}.
-++ A polynomial \spad{p} is said normalized w.r.t. a non-constant 
-++ polynomial \spad{q} if \spad{p} is constant or \spad{degree(p,mdeg(q)) = 0}
-++ and \spad{init(p)} is normalized w.r.t. \spad{q}. One of the important
-++ features of normalized triangular sets is that they are regular sets.\newline
 ++ References :
 ++  [1] D. LAZARD "A new method for solving algebraic systems of 
 ++      positive dimension" Discr. App. Math. 33:147-160,1991
@@ -25175,7 +25281,15 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++  [4] M. MORENO MAZA "Calculs de pgcd au-dessus des tours
 ++      d'extensions simples et resolution des systemes d'equations
 ++      algebriques" These, Universite P.etM. Curie, Paris, 1997.
-
+++ Description:
+++ The category of normalized triangular sets. A triangular
+++ set \spad{ts} is said normalized if for every algebraic
+++ variable \spad{v} of \spad{ts} the polynomial \spad{select(ts,v)}
+++ is normalized w.r.t. every polynomial in \spad{collectUnder(ts,v)}.
+++ A polynomial \spad{p} is said normalized w.r.t. a non-constant 
+++ polynomial \spad{q} if \spad{p} is constant or \spad{degree(p,mdeg(q)) = 0}
+++ and \spad{init(p)} is normalized w.r.t. \spad{q}. One of the important
+++ features of normalized triangular sets is that they are regular sets.
 
 NormalizedTriangularSetCategory(R:GcdDomain,E:OrderedAbelianMonoidSup,_
  V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)):
@@ -25319,6 +25433,7 @@ These exports come from \refto{AbelianGroup}():
 ++ Description:
 ++ Ordered sets which are also abelian groups, such that the 
 ++ addition preserves the ordering.
+
 OrderedAbelianGroup(): Category ==
         Join(OrderedCancellationAbelianMonoid, AbelianGroup)
 
@@ -25437,10 +25552,10 @@ These exports come from \refto{OrderedCancellationAbelianMonoid}():
 ++ partial order imposed by \spadop{-}, rather than with respect to
 ++ the total \spad{>} order (since that is "max").
 ++
-++ Axioms:
-++   \spad{sup(a,b)-a \~~= "failed"}
-++   \spad{sup(a,b)-b \~~= "failed"}
-++   \spad{x-a \~~= "failed" and x-b \~~= "failed" => x >= sup(a,b)}
+++ Axioms\br
+++ \tab{5}\spad{sup(a,b)-a \~~= "failed"}\br
+++ \tab{5}\spad{sup(a,b)-b \~~= "failed"}\br
+++ \tab{5}\spad{x-a \~~= "failed" and x-b \~~= "failed" => x >= sup(a,b)}\br
 
 OrderedAbelianMonoidSup(): Category == OrderedCancellationAbelianMonoid with
   sup: (%,%) -> %
@@ -25565,7 +25680,7 @@ is true if a set with $<$ which is transitive, but
 not($a < b$ or $a = b$) does not necessarily imply $b<a$.
 \item {\bf \cross{OMSAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{OMSAGG}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -25682,14 +25797,15 @@ These exports come from \refto{PriorityQueueAggregate}(S:OrderedSet):
 ++ An ordered-multiset aggregate is a multiset built over an ordered set S
 ++ so that the relative sizes of its entries can be assessed.
 ++ These aggregates serve as models for priority queues.
+
 OrderedMultisetAggregate(S:OrderedSet): Category ==
    Join(MultisetAggregate S,PriorityQueueAggregate S) with
-   -- max: % -> S		      ++ smallest entry in the set
+   -- max: % -> S                      ++ smallest entry in the set
    -- duplicates: % -> List Record(entry:S,count:NonNegativeInteger)
         ++ to become an in order iterator
-   -- parts: % -> List S	      ++ in order iterator
+   -- parts: % -> List S              ++ in order iterator
       min: % -> S
-	++ min(u) returns the smallest entry in the multiset aggregate u.
+        ++ min(u) returns the smallest entry in the multiset aggregate u.
 
 @
 <<OMSAGG.dotabb>>=
@@ -25859,6 +25975,7 @@ These exports come from \refto{Monoid}():
 ++ Description:
 ++ The category of rings with unity, always associative, but
 ++ not necessarily commutative.
+
 Ring(): Category == Join(Rng,Monoid,LeftModule(%)) with
       characteristic: () -> NonNegativeInteger
         ++ characteristic() returns the characteristic of the ring
@@ -25872,7 +25989,7 @@ Ring(): Category == Join(Rng,Monoid,LeftModule(%)) with
       unitsKnown
         ++ recip truly yields
         ++ reciprocal or "failed" if not a unit.
-        ++ Note: \spad{recip(0) = "failed"}.
+        ++ Note that \spad{recip(0) = "failed"}.
    add
       n:Integer
       coerce(n) == n * 1$%
@@ -26040,7 +26157,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{SFRTCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{SFRTCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -26195,15 +26312,6 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++ Also See: essai Graphisme
 ++ AMS Classifications:
 ++ Keywords: polynomial, multivariate, ordered variables set
-++ Description:
-++ The category of square-free regular triangular sets.
-++ A regular triangular set \spad{ts} is square-free if
-++ the gcd of any polynomial \spad{p} in \spad{ts} and 
-++ \spad{differentiate(p,mvar(p))} w.r.t. 
-++ \axiomOpFrom{collectUnder}{TriangularSetCategory}
-++                  (ts,\axiomOpFrom{mvar}{RecursivePolynomialCategory}(p))
-++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular
-++ set defines a tower of square-free simple extensions.\newline
 ++ References :
 ++  [1] D. LAZARD "A new method for solving algebraic systems of 
 ++      positive dimension" Discr. App. Math. 33:147-160,1991
@@ -26211,6 +26319,14 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++      Habilitation Thesis, ETZH, Zurich, 1995.
 ++  [3] M. MORENO MAZA "A new algorithm for computing triangular
 ++      decomposition of algebraic varieties" NAG Tech. Rep. 4/98.
+++ Description:
+++ The category of square-free regular triangular sets.
+++ A regular triangular set \spad{ts} is square-free if
+++ the gcd of any polynomial \spad{p} in \spad{ts} and 
+++ differentiate(p,mvar(p)) w.r.t. collectUnder(ts,mvar(p))
+++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular
+++ set defines a tower of square-free simple extensions.
+
 SquareFreeRegularTriangularSetCategory(R:GcdDomain,E:OrderedAbelianMonoidSup,_
   V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)):
          Category == 
@@ -26372,7 +26488,7 @@ digraph pic {
 is true if it is an aggregate with a finite number of elements.
 \item {\bf \cross{SRAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -26554,30 +26670,31 @@ These exports come from \refto{OneDimensionalArrayAggregate}(Character):
 ++ Description:
 ++ A string aggregate is a category for strings, that is,
 ++ one dimensional arrays of characters.
+
 StringAggregate: Category == OneDimensionalArrayAggregate Character with
-    lowerCase	    : % -> %
+    lowerCase            : % -> %
       ++ lowerCase(s) returns the string with all characters in lower case.
     lowerCase_!: % -> %
       ++ lowerCase!(s) destructively replaces the alphabetic characters
       ++ in s by lower case.
-    upperCase	    : % -> %
+    upperCase            : % -> %
       ++ upperCase(s) returns the string with all characters in upper case.
     upperCase_!: % -> %
       ++ upperCase!(s) destructively replaces the alphabetic characters
       ++ in s by upper case characters.
-    prefix?	    : (%, %) -> Boolean
+    prefix?            : (%, %) -> Boolean
       ++ prefix?(s,t) tests if the string s is the initial substring of t.
-      ++ Note: \axiom{prefix?(s,t) == 
+      ++ Note that \axiom{prefix?(s,t) == 
       ++   reduce(and,[s.i = t.i for i in 0..maxIndex s])}.
-    suffix?	    : (%, %) -> Boolean
+    suffix?            : (%, %) -> Boolean
       ++ suffix?(s,t) tests if the string s is the final substring of t.
-      ++ Note: \axiom{suffix?(s,t) == 
+      ++ Note that \axiom{suffix?(s,t) == 
       ++  reduce(and,[s.i = t.(n - m + i) for i in 0..maxIndex s])}
       ++ where m and n denote the maxIndex of s and t respectively.
     substring?: (%, %, Integer) -> Boolean
       ++ substring?(s,t,i) tests if s is a substring of t beginning at
       ++ index i.
-      ++ Note: \axiom{substring?(s,t,0) = prefix?(s,t)}.
+      ++ Note that \axiom{substring?(s,t,0) = prefix?(s,t)}.
     match: (%, %, Character) -> NonNegativeInteger
       ++ match(p,s,wc) tests if pattern \axiom{p} matches subject \axiom{s}
       ++ where \axiom{wc} is a wild card character. If no match occurs,
@@ -26591,16 +26708,16 @@ StringAggregate: Category == OneDimensionalArrayAggregate Character with
       ++ match?(s,t,c) tests if s matches t except perhaps for
       ++ multiple and consecutive occurrences of character c.
       ++ Typically c is the blank character.
-    replace	    : (%, UniversalSegment(Integer), %) -> %
+    replace            : (%, UniversalSegment(Integer), %) -> %
       ++ replace(s,i..j,t) replaces the substring \axiom{s(i..j)} 
       ++ of s by string t.
-    position	    : (%, %, Integer) -> Integer
+    position            : (%, %, Integer) -> Integer
       ++ position(s,t,i) returns the position j of the substring s in 
       ++ string t, where \axiom{j >= i} is required.
-    position	    : (CharacterClass, %, Integer) -> Integer
+    position            : (CharacterClass, %, Integer) -> Integer
       ++ position(cc,t,i) returns the position \axiom{j >= i} in t of
       ++ the first character belonging to cc.
-    coerce	    : Character -> %
+    coerce            : Character -> %
       ++ coerce(c) returns c as a string s with the character c.
     split: (%, Character) -> List %
       ++ split(s,c) returns a list of substrings delimited by character c.
@@ -26638,13 +26755,13 @@ StringAggregate: Category == OneDimensionalArrayAggregate Character with
       ++ allow juxtaposition of strings to work as concatenation.
       ++ For example, \axiom{"smoo" "shed"} returns \axiom{"smooshed"}.
  add
-   trim(s: %, c:  Character)	  == leftTrim(rightTrim(s, c),	c)
+   trim(s: %, c:  Character)          == leftTrim(rightTrim(s, c),        c)
    trim(s: %, cc: CharacterClass) == leftTrim(rightTrim(s, cc), cc)
-   lowerCase s		 == lowerCase_! copy s
-   upperCase s		 == upperCase_! copy s
-   prefix?(s, t)	 == substring?(s, t, minIndex t)
+   lowerCase s                 == lowerCase_! copy s
+   upperCase s                 == upperCase_! copy s
+   prefix?(s, t)         == substring?(s, t, minIndex t)
    coerce(c:Character):% == new(1, c)
-   elt(s:%, t:%): %	 == concat(s,t)$%
+   elt(s:%, t:%): %         == concat(s,t)$%
 
 @
 <<SRAGG.dotabb>>=
@@ -26762,7 +26879,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{TBAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf nil}
 \end{itemize}
@@ -26953,9 +27070,10 @@ and RecKE=Record(key: Key,entry: Entry):
 ++ Description:
 ++ A table aggregate is a model of a table, i.e. a discrete many-to-one
 ++ mapping from keys to entries.
+
 TableAggregate(Key:SetCategory, Entry:SetCategory): Category ==
   Join(KeyedDictionary(Key,Entry),IndexedAggregate(Key,Entry)) with
-   setelt: (%,Key,Entry) -> Entry	   -- setelt_! later
+   setelt: (%,Key,Entry) -> Entry           -- setelt_! later
      ++ setelt(t,k,e) (also written \axiom{t.k := e}) is equivalent
      ++ to \axiom{(insert([k,e],t); e)}.
    table: () -> %
@@ -26973,16 +27091,16 @@ TableAggregate(Key:SetCategory, Entry:SetCategory): Category ==
      ++ elements fn(x,y) where x and y are corresponding elements from t1
      ++ and t2 respectively.
  add
-   table()	       == empty()
-   table l	       == dictionary l
--- empty()	       == dictionary()
+   table()               == empty()
+   table l               == dictionary l
+-- empty()               == dictionary()
 
    insert_!(p, t)      == (t(p.key) := p.entry; t)
-   indices t	       == keys t
+   indices t               == keys t
 
    coerce(t:%):OutputForm ==
      prefix("table"::OutputForm,
-		    [k::OutputForm = (t.k)::OutputForm for k in keys t])
+                    [k::OutputForm = (t.k)::OutputForm for k in keys t])
 
    elt(t, k) ==
       (r := search(k, t)) case Entry => r::Entry
@@ -27017,23 +27135,23 @@ TableAggregate(Key:SetCategory, Entry:SetCategory): Category ==
        eq?(s,t) => true
        #s ^= #t => false
        for k in keys s repeat
-	 (e := search(k, t)) _
+         (e := search(k, t)) _
            case "failed" or (e::Entry) ^= s.k => return false
        true
 
      map(f: Record(key:Key,entry:Entry)->Record(key:Key,entry:Entry),t:%):%==
        z := table()
        for k in keys t repeat
-	 ke: Record(key:Key,entry:Entry) := f [k, t.k]
-	 z ke.key := ke.entry
+         ke: Record(key:Key,entry:Entry) := f [k, t.k]
+         z ke.key := ke.entry
        z
      map_!(f:Record(key:Key,entry:Entry)->Record(key:Key,entry:Entry),t:%):%_
       ==
        lke: List Record(key:Key,entry:Entry) := nil()
        for k in keys t repeat
-	 lke := cons(f [k, remove_!(k,t)::Entry], lke)
+         lke := cons(f [k, remove_!(k,t)::Entry], lke)
        for ke in lke repeat
-	 t ke.key := ke.entry
+         t ke.key := ke.entry
        t
 
      inspect(t: %): Record(key:Key,entry:Entry) ==
@@ -27224,7 +27342,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{VECTCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{VECTCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -27602,7 +27720,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{ALAGG}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{ALAGG}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -27925,14 +28043,15 @@ and RecKE=Record(key: Key,entry: Entry)
 ++ References:
 ++ Description:
 ++ An association list is a list of key entry pairs which may be viewed
-++ as a table.	It is a poor mans version of a table:
+++ as a table.        It is a poor mans version of a table:
 ++ searching for a key is a linear operation.
+
 AssociationListAggregate(Key:SetCategory,Entry:SetCategory): Category ==
    Join(TableAggregate(Key, Entry), _
          ListAggregate Record(key:Key,entry:Entry)) with
       assoc: (Key, %) -> Union(Record(key:Key,entry:Entry), "failed")
-	++ assoc(k,u) returns the element x in association list u stored
-	++ with key k, or "failed" if u has no key k.
+        ++ assoc(k,u) returns the element x in association list u stored
+        ++ with key k, or "failed" if u has no key k.
 
 @
 <<ALAGG.dotabb>>=
@@ -28080,6 +28199,7 @@ These exports come from \refto{Ring}():
 ++ References:
 ++ Description:
 ++ Rings of Characteristic Non Zero
+
 CharacteristicNonZero():Category == Ring with
     charthRoot: % -> Union(%,"failed")
        ++ charthRoot(x) returns the pth root of x
@@ -28227,6 +28347,7 @@ These exports come from \refto{Ring}():
 ++ References:
 ++ Description:
 ++ Rings of Characteristic Zero.
+
 CharacteristicZero():Category == Ring
 
 @
@@ -28381,8 +28502,9 @@ These exports come from \refto{Ring}():
 ++ References:
 ++ Description:
 ++ The category of commutative rings with unity, i.e. rings where
-++ \spadop{*} is commutative, and which have a multiplicative identity.
+++ \spadop{*} is commutative, and which have a multiplicative identity
 ++ element.
+
 --CommutativeRing():Category == Join(Ring,BiModule(%:Ring,%:Ring)) with
 CommutativeRing():Category == Join(Ring,BiModule(%,%)) with
     commutative("*")  ++ multiplication is commutative.
@@ -28554,9 +28676,9 @@ These exports come from \refto{Ring}():
 ++ An ordinary differential ring, that is, a ring with an operation
 ++ \spadfun{differentiate}.
 ++
-++ Axioms:
-++   \spad{differentiate(x+y) = differentiate(x)+differentiate(y)}
-++   \spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y}
+++ Axioms\br
+++ \tab{5}\spad{differentiate(x+y) = differentiate(x)+differentiate(y)}\br
+++ \tab{5}\spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y}
 
 DifferentialRing(): Category == Ring with
     differentiate: % -> %
@@ -28724,9 +28846,10 @@ These exports come from \refto{Ring}():
 ++ Entire Rings (non-commutative Integral Domains), i.e. a ring
 ++ not necessarily commutative which has no zero divisors.
 ++
-++ Axioms:
-++   \spad{ab=0 => a=0 or b=0}  -- known as noZeroDivisors
-++   \spad{not(1=0)}
+++ Axioms\br
+++ \tab{5}\spad{ab=0 => a=0 or b=0}  -- known as noZeroDivisors\br
+++ \tab{5}\spad{not(1=0)}
+
 --EntireRing():Category == Join(Ring,BiModule(%:Ring,%:Ring)) with
 EntireRing():Category == Join(Ring,BiModule(%,%)) with
       noZeroDivisors  ++ if a product is zero then one of the factors
@@ -28900,17 +29023,16 @@ These exports come from \refto{RetractableTo}(Basis:SetCategory):
 ++ Keywords:
 ++ References:
 ++ Description:
-++   A domain of this category 
-++   implements formal linear combinations
-++   of elements from a domain \spad{Basis} with coefficients
-++   in a domain \spad{R}. The domain \spad{Basis} needs only
-++   to belong to the category \spadtype{SetCategory} and \spad{R}
-++   to the category \spadtype{Ring}. Thus the coefficient ring
-++   may be non-commutative.
-++   See the \spadtype{XDistributedPolynomial} constructor
-++   for examples of domains built with the \spadtype{FreeModuleCat}
-++   category constructor.
-++   Author: Michel Petitot (petitot@lifl.fr)
+++ A domain of this category 
+++ implements formal linear combinations
+++ of elements from a domain \spad{Basis} with coefficients
+++ in a domain \spad{R}. The domain \spad{Basis} needs only
+++ to belong to the category \spadtype{SetCategory} and \spad{R}
+++ to the category \spadtype{Ring}. Thus the coefficient ring
+++ may be non-commutative.
+++ See the \spadtype{XDistributedPolynomial} constructor
+++ for examples of domains built with the \spadtype{FreeModuleCat}
+++ category constructor.
 
 FreeModuleCat(R, Basis):Category == Exports where
    R: Ring
@@ -29094,12 +29216,13 @@ These exports come from \refto{LeftModule}(R:Type):
 )abbrev category LALG LeftAlgebra
 ++ Author: Larry A. Lambe
 ++ Date  : 03/01/89; revised 03/17/89; revised 12/02/90.
-++ Description: The category of all left algebras over an arbitrary
-++ ring.
+++ Description:
+++ The category of all left algebras over an arbitrary ring.
+
 LeftAlgebra(R:Ring): Category == Join(Ring, LeftModule R) with
       coerce: R -> %
-	++ coerce(r) returns r * 1 where 1 is the identity of the
-	++ left algebra.
+        ++ coerce(r) returns r * 1 where 1 is the identity of the
+        ++ left algebra.
     add
       coerce(x:R):% == x * 1$%
 
@@ -29241,6 +29364,7 @@ These exports come from \refto{Ring}():
 ++ References:
 ++ Description:
 ++ An extension ring with an explicit linear dependence test.
+
 LinearlyExplicitRingOver(R:Ring): Category == Ring with
   reducedSystem: Matrix % -> Matrix R
     ++ reducedSystem(A) returns a matrix B such that \spad{A x = 0} 
@@ -29389,11 +29513,12 @@ These exports come from \refto{BiModule}(a:Ring,b:Ring):
 ++ Description:
 ++ The category of modules over a commutative ring.
 ++
-++ Axioms:
-++   \spad{1*x = x}
-++   \spad{(a*b)*x = a*(b*x)}
-++   \spad{(a+b)*x = (a*x)+(b*x)}
-++   \spad{a*(x+y) = (a*x)+(a*y)}
+++ Axioms\br
+++ \tab{5}\spad{1*x = x}\br
+++ \tab{5}\spad{(a*b)*x = a*(b*x)}\br
+++ \tab{5}\spad{(a+b)*x = (a*x)+(b*x)}\br
+++ \tab{5}\spad{a*(x+y) = (a*x)+(a*y)}
+
 Module(R:CommutativeRing): Category == BiModule(R,R)
   add
     if not(R is %) then x:%*r:R == r*x
@@ -29565,8 +29690,9 @@ These exports come from \refto{Ring}():
 ++ Ordered sets which are also rings, that is, domains where the ring
 ++ operations are compatible with the ordering.
 ++
-++ Axiom:
-++   \spad{0<a and b<c => ab< ac}
+++ Axiom\br
+++ \tab{5}\spad{0<a and b<c => ab< ac}
+
 OrderedRing(): Category == Join(OrderedAbelianGroup,Ring,Monoid) with
      positive?: % -> Boolean
        ++ positive?(x) tests whether x is strictly greater than 0.
@@ -29756,9 +29882,9 @@ These exports come from \refto{Ring}():
 ++ A partial differential ring with differentiations indexed by a 
 ++ parameter type S.
 ++
-++ Axioms:
-++  \spad{differentiate(x+y,e) = differentiate(x,e)+differentiate(y,e)}
-++  \spad{differentiate(x*y,e) = x*differentiate(y,e)+differentiate(x,e)*y}
+++ Axioms\br
+++ \tab{5}\spad{differentiate(x+y,e)=differentiate(x,e)+differentiate(y,e)}\br
+++ \tab{5}\spad{differentiate(x*y,e)=x*differentiate(y,e)+differentiate(x,e)*y}
 
 PartialDifferentialRing(S:SetCategory): Category == Ring with
     differentiate: (%, S) -> %
@@ -29960,7 +30086,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{PTCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{PTCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -30086,7 +30212,8 @@ These exports come from \refto{VectorCategory}(R:Ring):
 ++ AMS Classifications:
 ++ Keywords: 
 ++ References:
-++ Description: PointCategory is the category of points in space which
+++ Description:
+++ PointCategory is the category of points in space which
 ++ may be plotted via the graphics facilities.  Functions are provided for
 ++ defining points and handling elements of points.
  
@@ -30103,7 +30230,7 @@ PointCategory(R:Ring) : Category == VectorCategory(R) with
       ++ cross(p,q) computes the cross product of the two points \spad{p}
       ++ and \spad{q}. Error if the p and q are not 3 dimensional
   extend : (%,List R) -> %
-	++ extend(x,l,r) \undocumented
+        ++ extend(x,l,r) \undocumented
 
 @
 <<PTCAT.dotabb>>=
@@ -30334,10 +30461,10 @@ These exports come from \refto{HomogeneousAggregate}(Ring)"
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{RectangularMatrixCategory} is a category of matrices of fixed
-++   dimensions.  The dimensions of the matrix will be parameters of the
-++   domain.  Domains in this category will be R-modules and will be
-++   non-mutable.
+++ \spadtype{RectangularMatrixCategory} is a category of matrices of fixed
+++ dimensions. The dimensions of the matrix will be parameters of the
+++ domain. Domains in this category will be R-modules and will be non-mutable.
+
 RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where
   m,n : NonNegativeInteger
   R   : Ring
@@ -30407,8 +30534,8 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where
     qelt: (%,Integer,Integer) -> R
       ++ \spad{qelt(m,i,j)} returns the element in the \spad{i}th row and
       ++ \spad{j}th column of
-      ++ the matrix m. Note: there is NO error check to determine if indices 
-      ++ are in the proper ranges.
+      ++ the matrix m. Note that there is NO error check to determine 
+      ++ if indices are in the proper ranges.
     elt: (%,Integer,Integer,R) -> R
       ++ \spad{elt(m,i,j,r)} returns the element in the \spad{i}th row and
       ++ \spad{j}th column of the matrix m, if m has an \spad{i}th row and a
@@ -30643,7 +30770,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{SNTSCAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{SNTSCAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -30798,13 +30925,14 @@ P:RecursivePolynomialCategory(R,E,V)):
 ++ Also See: essai Graphisme
 ++ AMS Classifications:
 ++ Keywords: polynomial, multivariate, ordered variables set
+++ References :
+++ [1] D. LAZARD "A new method for solving algebraic systems of 
+++ positive dimension" Discr. App. Math. 33:147-160,1991
 ++ Description:
 ++ The category of square-free and normalized triangular sets.
 ++ Thus, up to the primitivity axiom of [1], these sets are Lazard
-++ triangular sets.\newline
-++ References :
-++  [1] D. LAZARD "A new method for solving algebraic systems of 
-++      positive dimension" Discr. App. Math. 33:147-160,1991
+++ triangular sets.
+
 SquareFreeNormalizedTriangularSetCategory(R:GcdDomain,_
                                           E:OrderedAbelianMonoidSup,_
                                           V:OrderedSet,_
@@ -30948,7 +31076,7 @@ digraph pic {
 \begin{itemize}
 \item {\bf \cross{STRICAT}{shallowlyMutable}}
 is true if its values have immediate components that are 
-updateable (mutable). Note: the properties of any component 
+updateable (mutable). Note that the properties of any component 
 domain are irrevelant to the shallowlyMutable proper.
 \item {\bf \cross{STRICAT}{finiteAggregate}}
 is true if it is an aggregate with a finite number of elements.
@@ -31356,13 +31484,13 @@ These exports come from \refto{FullyRetractableTo}(R:Ring):
 ++ Date Created: 19 October 1993
 ++ Date Last Updated: 1 February 1994
 ++ Description:
-++   This is the category of univariate skew polynomials over an Ore
-++   coefficient ring.
-++   The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
-++   This category is an evolution of the types
-++     MonogenicLinearOperator, OppositeMonogenicLinearOperator, and
-++     NonCommutativeOperatorDivision
-++   developped by Jean Della Dora and Stephen M. Watt.
+++ This is the category of univariate skew polynomials over an Ore
+++ coefficient ring.
+++ The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
+++ This category is an evolution of the types
+++ MonogenicLinearOperator, OppositeMonogenicLinearOperator, and
+++ NonCommutativeOperatorDivision
+
 UnivariateSkewPolynomialCategory(R:Ring):
   Category == Join(Ring, BiModule(R, R), FullyRetractableTo R) with
       degree: $ -> NonNegativeInteger
@@ -31787,11 +31915,9 @@ These exports come from \refto{BiModule}(R:Ring,R:Ring):
 ++ Keywords:
 ++ References:
 ++ Description:
-++   This is the category of algebras over non-commutative rings.
-++   It is used by constructors of non-commutative algebras such as:
-++       \spadtype{XPolynomialRing}.
-++       \spadtype{XFreeAlgebra}
-++   Author: Michel Petitot (petitot@lifl.fr)
+++ This is the category of algebras over non-commutative rings.
+++ It is used by constructors of non-commutative algebras such as
+++ XPolynomialRing and XFreeAlgebra
 
 XAlgebra(R: Ring): Category == 
   Join(Ring, BiModule(R,R)) with
@@ -31970,12 +32096,13 @@ These exports come from \refto{Module}(R:CommutativeRing):
 ++ Description:
 ++ The category of associative algebras (modules which are themselves rings).
 ++
-++ Axioms:
-++   \spad{(b+c)::% = (b::%) + (c::%)}
-++   \spad{(b*c)::% = (b::%) * (c::%)}
-++   \spad{(1::R)::% = 1::%}
-++   \spad{b*x = (b::%)*x}
-++   \spad{r*(a*b) = (r*a)*b = a*(r*b)}
+++ Axioms\br
+++ \tab{5}\spad{(b+c)::% = (b::%) + (c::%)}\br
+++ \tab{5}\spad{(b*c)::% = (b::%) * (c::%)}\br
+++ \tab{5}\spad{(1::R)::% = 1::%}\br
+++ \tab{5}\spad{b*x = (b::%)*x}\br
+++ \tab{5}\spad{r*(a*b) = (r*a)*b = a*(r*b)}
+
 Algebra(R:CommutativeRing): Category ==
   Join(Ring, Module R) with
       coerce: R -> %
@@ -32407,6 +32534,7 @@ These exports come from \refto{LinearlyExplicitRingOver}(a:Ring):
 ++ S is \spadtype{FullyLinearlyExplicitRingOver R} means that S is a
 ++ \spadtype{LinearlyExplicitRingOver R} and, in addition, if R is a
 ++ \spadtype{LinearlyExplicitRingOver Integer}, then so is S
+
 FullyLinearlyExplicitRingOver(R:Ring):Category ==
   LinearlyExplicitRingOver R with
     if (R has LinearlyExplicitRingOver Integer) then
@@ -32568,28 +32696,22 @@ These exports come from \refto{Module}(R:Ring):
 ++ Author: Michel Petitot (petitot@lifl.fr).
 ++ Date Created: 91
 ++ Date Last Updated: 7 Juillet 92
-++ Fix History: compilation v 2.1 le 13 dec 98
-++ Basic Functions:
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
 ++ Keywords:
 ++ References:
 ++ Description:
 ++ The category of Lie Algebras.
-++ It is used by the following domains of non-commutative algebra:
-++ \axiomType{LiePolynomial} and 
-++ \axiomType{XPBWPolynomial}. \newline 
-++ Author : Michel Petitot (petitot@lifl.fr).
+++ It is used by the domains of non-commutative algebra,
+++ LiePolynomial and XPBWPolynomial. 
+
 LieAlgebra(R: CommutativeRing): Category ==  Module(R) with
+    construct:  ($,$) -> $
+      ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} 
+      ++ and \axiom{y}.
     NullSquare 
       ++ \axiom{NullSquare} means that \axiom{[x,x] = 0} holds.
     JacobiIdentity 
       ++ \axiom{JacobiIdentity} means that 
       ++ \axiom{[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0} holds.
-    construct:  ($,$) -> $
-      ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} 
-      ++ and \axiom{y}.
     if R has Field then 
        "/"   :  ($,R) -> $
          ++ \axiom{x/r} returns the division of \axiom{x} by \axiom{r}.
@@ -32824,11 +32946,13 @@ These exports come from \refto{Eltable}(A:Ring,A:Ring):
 ++ Date Last Updated: 15 April 1994
 ++ Keywords: differential operator
 ++ Description:
-++   \spad{LinearOrdinaryDifferentialOperatorCategory} is the category
-++   of differential operators with coefficients in a ring A with a given
-++   derivation.
-++   Multiplication of operators corresponds to functional composition:
-++       \spad{(L1 * L2).(f) = L1 L2 f}
+++ LinearOrdinaryDifferentialOperatorCategory is the category
+++ of differential operators with coefficients in a ring A with a given
+++ derivation.
+++
+++ Multiplication of operators corresponds to functional composition:\br
+++ (L1 * L2).(f) = L1 L2 f
+
 LinearOrdinaryDifferentialOperatorCategory(A:Ring): Category ==
   Join(UnivariateSkewPolynomialCategory A, Eltable(A, A)) with
         D: () -> %
@@ -33061,13 +33185,15 @@ These exports come from \refto{Module}(R:CommutativeRing):
 ++ AMS Classifications:
 ++ Keywords: nonassociative algebra
 ++ Reference:
-++  R.D. Schafer: An Introduction to Nonassociative Algebras
-++  Academic Press, New York, 1966
+++ R.D. Schafer: An Introduction to Nonassociative Algebras
+++ Academic Press, New York, 1966
 ++ Description:
-++   NonAssociativeAlgebra is the category of non associative algebras
-++   (modules which are themselves non associative rngs).
-++   Axioms
-++      r*(a*b) = (r*a)*b = a*(r*b)
+++ NonAssociativeAlgebra is the category of non associative algebras
+++ (modules which are themselves non associative rngs).\br
+++
+++ Axioms\br
+++ \tab{5}r*(a*b) = (r*a)*b = a*(r*b)
+
 NonAssociativeAlgebra(R:CommutativeRing): Category == _
   Join(NonAssociativeRng, Module R) with
     plenaryPower : (%,PositiveInteger) -> %
@@ -33435,9 +33561,8 @@ where WORD:OrderedFreeMonoid(OrderedSet))
 ++ Keywords:
 ++ References:
 ++ Description:
-++    This category specifies opeations for  polynomials
-++    and formal series with non-commutative variables.
-++ Author: Michel Petitot (petitot@lifl.fr)
+++ This category specifies opeations for  polynomials
+++ and formal series with non-commutative variables.
 
 XFreeAlgebra(vl:OrderedSet,R:Ring):Category == Catdef where
    WORD   ==> OrderedFreeMonoid(vl)          -- monoide libre
@@ -33940,7 +34065,7 @@ These exports come from \refto{OrderedAbelianMonoidSup}():
 ++ Keywords:
 ++ References:
 ++ Description:
-++   This category represents a finite cartesian product of a given type.
+++ This category represents a finite cartesian product of a given type.
 ++ Many categorical properties are preserved under this construction.
  
 DirectProductCategory(dim:NonNegativeInteger, R:Type): Category ==
@@ -34473,8 +34598,9 @@ These exports come from \refto{NonAssociativeAlgebra}(R:CommutativeRing):
 ++   R. Wisbauer: Bimodule Structure of Algebra
 ++   Lecture Notes Univ. Duesseldorf 1991
 ++ Description:
-++   A FiniteRankNonAssociativeAlgebra is a non associative algebra over
-++   a commutative ring R which is a free \spad{R}-module of finite rank.
+++ A FiniteRankNonAssociativeAlgebra is a non associative algebra over
+++ a commutative ring R which is a free \spad{R}-module of finite rank.
+
 FiniteRankNonAssociativeAlgebra(R:CommutativeRing):
  Category == NonAssociativeAlgebra R with
     someBasis : () -> Vector %
@@ -34525,14 +34651,14 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing):
       ++ leftDiscriminant([v1,...,vn]) returns  the determinant of the
       ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row
       ++ and \spad{j}-th column is given by the left trace of the product
-      ++ \spad{vi*vj}.
-      ++ Note: the same as \spad{determinant(leftTraceMatrix([v1,...,vn]))}.
+      ++ \spad{vi*vj}. Note that this is the same as 
+      ++ \spad{determinant(leftTraceMatrix([v1,...,vn]))}.
     rightDiscriminant: Vector % -> R
       ++ rightDiscriminant([v1,...,vn]) returns  the determinant of the
       ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row
       ++ and \spad{j}-th column is given by the right trace of the product
-      ++ \spad{vi*vj}.
-      ++ Note: the same as \spad{determinant(rightTraceMatrix([v1,...,vn]))}.
+      ++ \spad{vi*vj}. Note that this is the same as 
+      ++ \spad{determinant(rightTraceMatrix([v1,...,vn]))}.
     leftTraceMatrix: Vector % -> Matrix R
       ++ leftTraceMatrix([v1,...,vn]) is the \spad{n}-by-\spad{n} matrix
       ++ whose element at the \spad{i}-th row and \spad{j}-th column is given
@@ -34560,7 +34686,7 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing):
     antiCommutative?:()-> Boolean
       ++ antiCommutative?() tests if \spad{a*a = 0}
       ++ for all \spad{a} in the algebra.
-      ++ Note: this implies \spad{a*b + b*a = 0} for all 
+      ++ Note that this implies \spad{a*b + b*a = 0} for all 
       ++ \spad{a} and \spad{b}.
     associative?:()-> Boolean
       ++ associative?() tests if multiplication in algebra
@@ -34572,23 +34698,23 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing):
     leftAlternative?: ()-> Boolean
       ++ leftAlternative?() tests if \spad{2*associator(a,a,b) = 0}
       ++ for all \spad{a}, b in the algebra.
-      ++ Note: we only can test this; in general we don't know
+      ++ Note that we only can test this; in general we don't know
       ++ whether \spad{2*a=0} implies \spad{a=0}.
     rightAlternative?: ()-> Boolean
       ++ rightAlternative?() tests if \spad{2*associator(a,b,b) = 0}
       ++ for all \spad{a}, b in the algebra.
-      ++ Note: we only can test this; in general we don't know
+      ++ Note that we only can test this; in general we don't know
       ++ whether \spad{2*a=0} implies \spad{a=0}.
     flexible?: ()->  Boolean
       ++ flexible?() tests if \spad{2*associator(a,b,a) = 0}
       ++ for all \spad{a}, b in the algebra.
-      ++ Note: we only can test this; in general we don't know
+      ++ Note that we only can test this; in general we don't know
       ++ whether \spad{2*a=0} implies \spad{a=0}.
     alternative?: ()-> Boolean
       ++ alternative?() tests if
       ++ \spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)}
       ++ for all \spad{a}, b in the algebra.
-      ++ Note: we only can test this; in general we don't know
+      ++ Note that we only can test this; in general we don't know
       ++ whether \spad{2*a=0} implies \spad{a=0}.
     powerAssociative?:()-> Boolean
       ++ powerAssociative?() tests if all subalgebras
@@ -34652,13 +34778,13 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing):
       leftMinimalPolynomial : % -> SparseUnivariatePolynomial R
         ++ leftMinimalPolynomial(a) returns the polynomial determined by the
         ++ smallest non-trivial linear combination of left powers of 
-        ++ \spad{a}. Note: the polynomial never has a constant term as in 
+        ++ \spad{a}. Note that the polynomial never has a constant term as in 
         ++ general the algebra has no unit.
       rightMinimalPolynomial : % -> SparseUnivariatePolynomial R
         ++ rightMinimalPolynomial(a) returns the polynomial determined by the
         ++ smallest non-trivial linear
         ++ combination of right powers of \spad{a}.
-        ++ Note: the polynomial never has a constant term as in general
+        ++ Note that the polynomial never has a constant term as in general
         ++ the algebra has no unit.
       leftUnits:() -> Union(Record(particular: %, basis: List %), "failed")
         ++ leftUnits() returns the affine space of all left units of the
@@ -35284,7 +35410,7 @@ These exports come from \refto{LieAlgebra}(CommutativeRing):
 ++ The category of free Lie algebras.
 ++ It is used by domains of non-commutative algebra:
 ++ \spadtype{LiePolynomial} and 
-++ \spadtype{XPBWPolynomial}. \newline Author: Michel Petitot (petitot@lifl.fr)
+++ \spadtype{XPBWPolynomial}. 
 
 FreeLieAlgebra(VarSet:OrderedSet, R:CommutativeRing) :Category == _
  CatDef where
@@ -35524,10 +35650,10 @@ These exports come from \refto{Algebra}(a:IntegralDomain):
 ++ The category of commutative integral domains, i.e. commutative
 ++ rings with no zero divisors.
 ++
-++ Conditional attributes:
-++   canonicalUnitNormal\tab{20}the canonical field is the same for 
-++   all associates canonicalsClosed\tab{20}the product of two 
-++   canonicals is itself canonical
+++ Conditional attributes\br
+++ canonicalUnitNormal\tab{5}the canonical field is the same for 
+++ all associates\br
+++ canonicalsClosed\tab{5}the product of two canonicals is itself canonical
 
 IntegralDomain(): Category ==
   Join(CommutativeRing, Algebra(%), EntireRing) with
@@ -35733,18 +35859,18 @@ These exports come from \refto{Algebra}(R:CommutativeRing):
 ++ Examples:
 ++ References:
 ++ Description:
-++   This is the category of linear operator rings with one generator.
-++   The generator is not named by the category but can always be
-++   constructed as \spad{monomial(1,1)}.
+++ This is the category of linear operator rings with one generator.
+++ The generator is not named by the category but can always be
+++ constructed as \spad{monomial(1,1)}.
 ++
-++   For convenience, call the generator \spad{G}.
-++   Then each value is equal to
-++       \spad{sum(a(i)*G**i, i = 0..n)}
-++   for some unique \spad{n} and \spad{a(i)} in \spad{R}.
+++ For convenience, call the generator \spad{G}.
+++ Then each value is equal to
+++ \spad{sum(a(i)*G**i, i = 0..n)}
+++ for some unique \spad{n} and \spad{a(i)} in \spad{R}.
 ++
-++   Note that multiplication is not necessarily commutative.
-++   In fact,  if \spad{a} is in \spad{R}, it is quite normal
-++   to have \spad{a*G \^= G*a}.
+++ Note that multiplication is not necessarily commutative.
+++ In fact,  if \spad{a} is in \spad{R}, it is quite normal
+++ to have \spad{a*G \^= G*a}.
 
 MonogenicLinearOperator(R): Category == Defn where
     E ==> NonNegativeInteger
@@ -36048,11 +36174,10 @@ These exports come from \refto{CharacteristicNonZero}():
 ++  Hypercomplex Numbers, Springer Verlag Heidelberg, 1989,
 ++  ISBN 0-387-96980-2
 ++ Description:
-++  OctonionCategory gives the categorial frame for the 
-++  octonions, and eight-dimensional non-associative algebra, 
-++  doubling the the quaternions in the same way as doubling
-++  the Complex numbers to get the quaternions.
--- Examples: octonion.input
+++ OctonionCategory gives the categorial frame for the 
+++ octonions, and eight-dimensional non-associative algebra, 
+++ doubling the the quaternions in the same way as doubling
+++ the Complex numbers to get the quaternions.
  
 OctonionCategory(R: CommutativeRing): Category ==
   -- we are cheating a little bit, algebras in \Language{}
@@ -36564,8 +36689,8 @@ These exports come from \refto{CharacteristicNonZero}():
 ++ AMS Classifications: 11R52
 ++ Keywords: quaternions, division ring, algebra
 ++ Description:
-++   \spadtype{QuaternionCategory} describes the category of quaternions
-++   and implements functions that are not representation specific.
+++ \spadtype{QuaternionCategory} describes the category of quaternions
+++ and implements functions that are not representation specific.
  
 QuaternionCategory(R: CommutativeRing): Category ==
   Join(Algebra R, FullyRetractableTo R, DifferentialExtension R,
@@ -36611,7 +36736,7 @@ QuaternionCategory(R: CommutativeRing): Category ==
        rationalIfCan: $ -> Union(Fraction Integer, "failed")
          ++ rationalIfCan(q) returns \spad{q} as a rational number,
          ++ or "failed" if this is not possible.
-         ++ Note: if \spad{rational?(q)} is true, the conversion
+         ++ Note that if \spad{rational?(q)} is true, the conversion
          ++ can be done and the rational number will be returned.
  
  add
@@ -37067,10 +37192,11 @@ These exports come from \refto{FullyLinearlyExplicitRingOver}(R:Ring):
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{SquareMatrixCategory} is a general square matrix category which
-++   allows different representations and indexing schemes.  Rows and
-++   columns may be extracted with rows returned as objects of
-++   type Row and colums returned as objects of type Col.
+++ \spadtype{SquareMatrixCategory} is a general square matrix category which
+++ allows different representations and indexing schemes.  Rows and
+++ columns may be extracted with rows returned as objects of
+++ type Row and colums returned as objects of type Col.
+
 SquareMatrixCategory(ndim,R,Row,Col): Category == Definition where
   ndim : NonNegativeInteger
   R    : Ring
@@ -37465,10 +37591,9 @@ These exports come from \refto{SetCategory}():
 ++ Keywords:
 ++ References:
 ++ Description:
-++   The Category of polynomial rings with non-commutative variables.
-++   The coefficient ring may be non-commutative too. 
-++   However coefficients commute with vaiables.
-++ Author: Michel Petitot (petitot@lifl.fr)
+++ The Category of polynomial rings with non-commutative variables.
+++ The coefficient ring may be non-commutative too. 
+++ However coefficients commute with vaiables.
 
 XPolynomialsCat(vl:OrderedSet,R:Ring):Category == Export where
   WORD ==> OrderedFreeMonoid(vl)
@@ -37736,6 +37861,7 @@ These exports come from \refto{Algebra}(Fraction(Integer)):
 ++ See \spadtype{FiniteAbelianMonoidRing} for the case of finite support
 ++ a useful common model for polynomials and power series.
 ++ Conceptually at least, only the non-zero terms are ever operated on.
+
 AbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category ==
      Join(Ring,BiModule(R,R)) with
   leadingCoefficient: % -> R
@@ -37986,8 +38112,10 @@ These exports come from \refto{RetractableTo}(Integer):
 ++ Keywords:
 ++ Examples:
 ++ References:
-++ Description: A category of domains which model machine arithmetic
+++ Description:
+++ A category of domains which model machine arithmetic
 ++ used by machines in the AXIOM-NAG link.
+
 FortranMachineTypeCategory():Category == Join(IntegralDomain,OrderedSet,
                                               RetractableTo(Integer) )
 
@@ -38301,10 +38429,11 @@ where R:CommutativeRing:
 ++  R.D. Schafer: An Introduction to Nonassociative Algebras
 ++  Academic Press, New York, 1966
 ++ Description:
-++   FramedNonAssociativeAlgebra(R) is a
-++   \spadtype{FiniteRankNonAssociativeAlgebra} (i.e. a non associative
-++   algebra over R which is a free \spad{R}-module of finite rank)
-++   over a commutative ring R together with a fixed \spad{R}-module basis.
+++ FramedNonAssociativeAlgebra(R) is a
+++ \spadtype{FiniteRankNonAssociativeAlgebra} (i.e. a non associative
+++ algebra over R which is a free \spad{R}-module of finite rank)
+++ over a commutative ring R together with a fixed \spad{R}-module basis.
+
 FramedNonAssociativeAlgebra(R:CommutativeRing):
         Category == FiniteRankNonAssociativeAlgebra(R) with
     basis: () -> Vector %
@@ -38347,7 +38476,7 @@ FramedNonAssociativeAlgebra(R:CommutativeRing):
       ++ is given by the left trace of the product \spad{vi*vj}, where
       ++ \spad{v1},...,\spad{vn} are the
       ++ elements of the fixed \spad{R}-module basis.
-      ++ Note: the same as \spad{determinant(leftTraceMatrix())}.
+      ++ Note that the same as \spad{determinant(leftTraceMatrix())}.
     rightDiscriminant : () -> R
       ++ rightDiscriminant() returns the determinant of the 
       ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row 
@@ -38355,7 +38484,7 @@ FramedNonAssociativeAlgebra(R:CommutativeRing):
       ++ given by the right trace of the product \spad{vi*vj}, where
       ++ \spad{v1},...,\spad{vn} are the elements of
       ++ the fixed \spad{R}-module basis.
-      ++ Note: the same as \spad{determinant(rightTraceMatrix())}.
+      ++ Note that the same as \spad{determinant(rightTraceMatrix())}.
     leftTraceMatrix : () -> Matrix R
       ++ leftTraceMatrix() is the \spad{n}-by-\spad{n}
       ++ matrix whose element at the \spad{i}-th row and \spad{j}-th column
@@ -39023,7 +39152,6 @@ These exports come from \refto{OrderedRing}():
 ++ Description:
 ++ The category of ordered commutative integral domains, where ordering
 ++ and the arithmetic operations are compatible
-++
 
 OrderedIntegralDomain(): Category ==
   Join(IntegralDomain, OrderedRing) 
@@ -39269,9 +39397,9 @@ These exports come from \refto{FullyRetractableTo}(R:Ring):
 ++ AMS Classifications:
 ++ Keywords:
 ++ References:
-++ Description: This category is
-++ similar to AbelianMonoidRing, except that the sum is assumed to be finite.
-++ It is a useful model for polynomials,
+++ Description: 
+++ This category is similar to AbelianMonoidRing, except that the sum is 
+++ assumed to be finite. It is a useful model for polynomials,
 ++ but is somewhat more general.
 
 FiniteAbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category ==
@@ -39689,18 +39817,19 @@ These exports come from \refto{RetractableTo}(Integer):
 
 <<category INTCAT IntervalCategory>>=
 )abbrev category INTCAT IntervalCategory
-+++ Author: Mike Dewar
-+++ Date Created: November 1996
-+++ Date Last Updated:
-+++ Basic Functions:
-+++ Related Constructors: 
-+++ Also See:
-+++ AMS Classifications:
-+++ Keywords:
-+++ References:
-+++ Description:
-+++ This category implements of interval arithmetic and transcendental
-+++ functions over intervals.
+++ Author: Mike Dewar
+++ Date Created: November 1996
+++ Date Last Updated:
+++ Basic Functions:
+++ Related Constructors: 
+++ Also See:
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ Description:
+++ This category implements of interval arithmetic and transcendental
+++ functions over intervals.
+
 IntervalCategory(R: Join(FloatingPointSystem,TranscendentalFunctionCategory)):
  Category == _
   Join(GcdDomain, OrderedSet, TranscendentalFunctionCategory, _
@@ -39961,8 +40090,9 @@ where Coef:Ring and Expon:OrderedAbelianMonoid:
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{PowerSeriesCategory} is the most general power series
-++   category with exponents in an ordered abelian monoid.
+++ \spadtype{PowerSeriesCategory} is the most general power series
+++ category with exponents in an ordered abelian monoid.
+
 PowerSeriesCategory(Coef,Expon,Var): Category == Definition where
   Coef  : Ring
   Expon : OrderedAbelianMonoid
@@ -39990,7 +40120,7 @@ PowerSeriesCategory(Coef,Expon,Var): Category == Definition where
       ++ \spad{pole?(f)} determines if the power series f has a pole.
     complete: % -> %
       ++ \spad{complete(f)} causes all terms of f to be computed.
-      ++ Note: this results in an infinite loop
+      ++ Note that this results in an infinite loop
       ++ if f has infinitely many terms.
 
    add
@@ -40646,9 +40776,9 @@ These exports come from \refto{PrincipalIdealDomain}():
 ++ a quotient and a remainder where the remainder is either zero
 ++ or is smaller (\spadfun{euclideanSize}) than the divisor.
 ++
-++ Conditional attributes:
-++   multiplicativeValuation\tab{25}\spad{Size(a*b)=Size(a)*Size(b)}
-++   additiveValuation\tab{25}\spad{Size(a*b)=Size(a)+Size(b)}
+++ Conditional attributes\br
+++ \tab{5}multiplicativeValuation\tab{5}Size(a*b)=Size(a)*Size(b)\br
+++ \tab{5}additiveValuation\tab{11}Size(a*b)=Size(a)+Size(b)
 
 EuclideanDomain(): Category == PrincipalIdealDomain with
    sizeLess?: (%,%) -> Boolean
@@ -41088,8 +41218,9 @@ These exports come from \refto{TranscendentalFunctionCategory}():
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{MultivariateTaylorSeriesCategory} is the most general
-++   multivariate Taylor series category.
+++ \spadtype{MultivariateTaylorSeriesCategory} is the most general
+++ multivariate Taylor series category.
+
 MultivariateTaylorSeriesCategory(Coef,Var): Category == Definition where
   Coef  : Ring
   Var   : OrderedSet
@@ -41676,13 +41807,14 @@ These exports come from \refto{PartialDifferentialRing}(Symbol):
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{UnivariatePowerSeriesCategory} is the most general
-++   univariate power series category with exponents in an ordered
-++   abelian monoid.
-++   Note: this category exports a substitution function if it is
-++   possible to multiply exponents.
-++   Note: this category exports a derivative operation if it is possible
-++   to multiply coefficients by exponents.
+++ \spadtype{UnivariatePowerSeriesCategory} is the most general
+++ univariate power series category with exponents in an ordered
+++ abelian monoid.
+++ Note that this category exports a substitution function if it is
+++ possible to multiply exponents.
+++ Also note that this category exports a derivative operation if it is 
+++ possible to multiply coefficients by exponents.
+
 UnivariatePowerSeriesCategory(Coef,Expon): Category == Definition where
   Coef   : Ring
   Expon  : OrderedAbelianMonoid
@@ -42045,9 +42177,9 @@ These exports come from \refto{DivisionRing}():
 ++ where all non-zero elements have multiplicative inverses.
 ++ The \spadfun{factor} operation while trivial is useful to have defined.
 ++
-++ Axioms:
-++   \spad{a*(b/a) = b}
-++   \spad{inv(a) = 1/a}
+++ Axioms\br
+++ \tab{5}\spad{a*(b/a) = b}\br
+++ \tab{5}\spad{inv(a) = 1/a}
 
 Field(): Category == Join(EuclideanDomain,UniqueFactorizationDomain,
   DivisionRing) with
@@ -42389,14 +42521,11 @@ These exports come from \refto{LinearlyExplicitRingOver}(Integer):
 <<category INS IntegerNumberSystem>>=
 )abbrev category INS IntegerNumberSystem
 ++ Author: Stephen M. Watt
-++ Date Created:
-++   January 1988
+++ Date Created: January 1988
 ++ Change History:
-++ Basic Operations:
-++   addmod, base, bit?, copy, dec, even?, hash, inc, invmod, length, mask,
-++   positiveRemainder, symmetricRemainder, multiplicativeValuation, mulmod,
-++   odd?, powmod, random, rational, rational?, rationalIfCan, shift, submod
-++ Description:  An \spad{IntegerNumberSystem} is a model for the integers.
+++ Description:
+++ An \spad{IntegerNumberSystem} is a model for the integers.
+
 IntegerNumberSystem(): Category ==
   Join(UniqueFactorizationDomain, EuclideanDomain, OrderedIntegralDomain,
          DifferentialRing, ConvertibleTo Integer, RetractableTo Integer,
@@ -42787,8 +42916,10 @@ These exports come from \refto{EuclideanDomain}():
 ++ Keywords: p-adic, completion
 ++ Examples:
 ++ References:
-++ Description: This is the category of stream-based representations of
-++   the p-adic integers.
+++ Description: 
+++ This is the category of stream-based representations of
+++ the p-adic integers.
+
 PAdicIntegerCategory(p): Category == Definition where
   p   :   Integer
   I   ==> Integer
@@ -43358,7 +43489,7 @@ PolynomialCategory(R:Ring, E:OrderedAbelianMonoidSup, VarSet:OrderedSet):
       ++ appearing in the polynomial p.
     primitiveMonomials: % -> List %
       ++ primitiveMonomials(p) gives the list of monomials of the
-      ++ polynomial p with their coefficients removed. Note:
+      ++ polynomial p with their coefficients removed. Note that
       ++ \spad{primitiveMonomials(sum(a_(i) X^(i))) = [X^(1),...,X^(n)]}.
     if R has OrderedSet  then OrderedSet
     -- OrderedRing view removed to allow EXPR to define abs
@@ -44099,8 +44230,9 @@ These exports come from \refto{RadicalCategory}():
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{UnivariateTaylorSeriesCategory} is the category of Taylor
-++   series in one variable.
+++ \spadtype{UnivariateTaylorSeriesCategory} is the category of Taylor
+++ series in one variable.
+
 UnivariateTaylorSeriesCategory(Coef): Category == Definition where
   Coef  : Ring
   I    ==> Integer
@@ -44856,9 +44988,9 @@ These exports come from \refto{RadicalCategory}():
 ++ Author: Manuel Bronstein
 ++ Date Created: 22 Mar 1988
 ++ Date Last Updated: 27 November 1991
-++ Description:
-++   Model for algebraically closed fields.
 ++ Keywords: algebraic, closure, field.
+++ Description:
+++ Model for algebraically closed fields.
 
 AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with
     rootOf: Polynomial $ -> $
@@ -44880,7 +45012,7 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with
       ++X rootOf(a,x)
     rootsOf: Polynomial $ -> List $
       ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
-      ++ Note: the returned symbols y1,...,yn are bound in the
+      ++ Note that the returned symbols y1,...,yn are bound in the
       ++ interpreter to respective root values.
       ++ Error: if p has more than one variable y.
       ++
@@ -44888,7 +45020,7 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with
       ++X rootsOf(a)
     rootsOf: SparseUnivariatePolynomial $ -> List $
       ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
-      ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+      ++ Note that the returned symbols y1,...,yn are bound in the interpreter
       ++ to respective root values.
       ++
       ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13
@@ -44896,7 +45028,7 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with
     rootsOf: (SparseUnivariatePolynomial $, Symbol) -> List $
       ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0};
       ++ The returned roots display as \spad{'y1},...,\spad{'yn}.
-      ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+      ++ Note that the returned symbols y1,...,yn are bound in the interpreter
       ++ to respective root values.
       ++
       ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13
@@ -45489,31 +45621,30 @@ These exports come from \refto{Evalable}(%:DPOLCAT):
 ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups"
 ++   (Academic Press, 1973).
 ++ Description:
-++   \spadtype{DifferentialPolynomialCategory} is a category constructor
-++   specifying basic functions in an ordinary differential polynomial
-++   ring with a given ordered set of differential indeterminates.
-++   In addition, it implements defaults for the basic functions.
-++   The functions \spadfun{order} and \spadfun{weight} are extended
-++   from the set of derivatives of differential indeterminates
-++   to the set of differential polynomials.  Other operations
-++   provided on differential polynomials are
-++   \spadfun{leader}, \spadfun{initial},
-++   \spadfun{separant}, \spadfun{differentialVariables}, and
-++   \spadfun{isobaric?}.   Furthermore, if the ground ring is
-++   a differential ring, then evaluation (substitution
-++   of differential indeterminates by elements of the ground ring
-++   or by differential polynomials) is
-++   provided by \spadfun{eval}.
-++   A convenient way of referencing derivatives is provided by
-++   the functions \spadfun{makeVariable}.
-++
-++   To construct a domain using this constructor, one needs
-++   to provide a ground ring R, an ordered set S of differential
-++   indeterminates, a ranking V on the set of derivatives
-++   of the differential indeterminates, and a set E of
-++   exponents in bijection with the set of differential monomials
-++   in the given differential indeterminates.
+++ \spadtype{DifferentialPolynomialCategory} is a category constructor
+++ specifying basic functions in an ordinary differential polynomial
+++ ring with a given ordered set of differential indeterminates.
+++ In addition, it implements defaults for the basic functions.
+++ The functions \spadfun{order} and \spadfun{weight} are extended
+++ from the set of derivatives of differential indeterminates
+++ to the set of differential polynomials.  Other operations
+++ provided on differential polynomials are
+++ \spadfun{leader}, \spadfun{initial},
+++ \spadfun{separant}, \spadfun{differentialVariables}, and
+++ \spadfun{isobaric?}.   Furthermore, if the ground ring is
+++ a differential ring, then evaluation (substitution
+++ of differential indeterminates by elements of the ground ring
+++ or by differential polynomials) is
+++ provided by \spadfun{eval}.
+++ A convenient way of referencing derivatives is provided by
+++ the functions \spadfun{makeVariable}.
 ++
+++ To construct a domain using this constructor, one needs
+++ to provide a ground ring R, an ordered set S of differential
+++ indeterminates, a ranking V on the set of derivatives
+++ of the differential indeterminates, and a set E of
+++ exponents in bijection with the set of differential monomials
+++ in the given differential indeterminates.
 
 DifferentialPolynomialCategory(R:Ring,S:OrderedSet,
   V:DifferentialVariableCategory S, E:OrderedAbelianMonoidSup):
@@ -45531,7 +45662,7 @@ DifferentialPolynomialCategory(R:Ring,S:OrderedSet,
        ++ indeterminate,  in such a way that the n-th
        ++ derivative of s may be simply referenced as z.n
        ++ where z :=makeVariable(s).
-       ++ Note: In the interpreter, z is
+       ++ Note that In the interpreter, z is
        ++ given as an internal map, which may be ignored.
        -- Example: makeVariable('s); %.5
 
@@ -45573,7 +45704,7 @@ DifferentialPolynomialCategory(R:Ring,S:OrderedSet,
     leader: $   -> V
       ++ leader(p) returns the derivative of the highest rank
       ++ appearing in the differential polynomial p
-      ++ Note: an error occurs if p is in the ground ring.
+      ++ Note that an error occurs if p is in the ground ring.
     initial:$   -> $
       ++ initial(p) returns the
       ++ leading coefficient when the differential polynomial p
@@ -45591,7 +45722,7 @@ DifferentialPolynomialCategory(R:Ring,S:OrderedSet,
        ++ ring,  in such a way that the n-th
        ++ derivative of p may be simply referenced as z.n
        ++ where z := makeVariable(p).
-       ++ Note: In the interpreter, z is
+       ++ Note that In the interpreter, z is
        ++ given as an internal map, which may be ignored.
        -- Example: makeVariable(p); %.5; makeVariable(%**2); %.2
 
@@ -45974,10 +46105,11 @@ These exports come from \refto{CharacteristicNonZero}():
 ++  J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM.
 ++  AXIOM Technical Report Series, ATR/5 NP2522.
 ++ Description:
-++  FieldOfPrimeCharacteristic is the category of fields of prime
-++  characteristic, e.g. finite fields, algebraic closures of
-++  fields of prime characteristic, transcendental extensions of
-++  of fields of prime characteristic.
+++ FieldOfPrimeCharacteristic is the category of fields of prime
+++ characteristic, e.g. finite fields, algebraic closures of
+++ fields of prime characteristic, transcendental extensions of
+++ of fields of prime characteristic.
+
 FieldOfPrimeCharacteristic:Category == _
  Join(Field,CharacteristicNonZero) with
    order: $ -> OnePointCompletion PositiveInteger
@@ -46776,10 +46908,10 @@ These exports come from \refto{RetractableTo}(Fraction(Integer)):
 ++ Author: Manuel Bronstein
 ++ Date Created: 22 March 1988
 ++ Date Last Updated: 14 February 1994
-++ Description:
-++   A space of formal functions with arguments in an arbitrary
-++   ordered set.
 ++ Keywords: operator, kernel, function.
+++ Description:
+++ A space of formal functions with arguments in an arbitrary ordered set.
+
 FunctionSpace(R:OrderedSet): Category == Definition where
   OP ==> BasicOperator
   O  ==> OutputForm
@@ -47921,8 +48053,9 @@ These exports come from \refto{PolynomialFactorizationExplicit}():
 ++ AMS Classifications:
 ++ Keywords:
 ++ References:
-++ Description: QuotientField(S) is the
-++ category of fractions of an Integral Domain S.
+++ Description:
+++ QuotientField(S) is the category of fractions of an Integral Domain S.
+
 QuotientFieldCategory(S: IntegralDomain): Category ==
   Join(Field, Algebra S, RetractableTo S, FullyEvalableOver S,
          DifferentialExtension S, FullyLinearlyExplicitRingOver S,
@@ -48386,6 +48519,7 @@ These exports come from \refto{Algebra}(Integer):
 ++ Description:
 ++ \axiomType{RealClosedField} provides common acces
 ++ functions for all real closed fields.
+
 RealClosedField : Category == PUB where
 
     E ==> OutputForm
@@ -48803,7 +48937,6 @@ These exports come from \refto{CharacteristicZero}():
 ++ Date Created:
 ++   January 1988
 ++ Change History:
-++ Basic Operations: abs, ceiling, wholePart, floor, fractionPart, norm, round, truncate
 ++ Related Constructors:
 ++ Keywords: real numbers
 ++ Description:  
@@ -48812,6 +48945,7 @@ These exports come from \refto{CharacteristicZero}():
 ++ we have purposely not included \spadtype{DifferentialRing} or 
 ++ the elementary functions (see \spadtype{TranscendentalFunctionCategory})
 ++ in the definition.
+
 RealNumberSystem(): Category ==
   Join(Field, OrderedRing, RealConstant, RetractableTo Integer,
        RetractableTo Fraction Integer, RadicalCategory,
@@ -49416,7 +49550,6 @@ where R:Ring, E:OrderedAbelianMonoidSup, V:OrderedSet:
 ++ Author: Marc Moreno Maza
 ++ Date Created: 04/22/1994
 ++ Date Last Updated: 14/12/1998
-++ Basic Functions: mvar, mdeg, init, head, tail, prem, lazyPrem
 ++ Related Constructors:
 ++ Also See: 
 ++ AMS Classifications:
@@ -49763,7 +49896,7 @@ RecursivePolynomialCategory(R:Ring, E:OrderedAbelianMonoidSup, V:OrderedSet):_
        next_subResultant2: ($, $, $, $) -> $
            ++ \axiom{nextsubResultant2(p,q,z,s)} is the multivariate version
            ++ of the operation 
-           ++ \axiomOpFrom{next_sousResultant2}{PseudoRemainderSequence} from
+           ++ next_sousResultant2 from PseudoRemainderSequence from
            ++ the \axiomType{PseudoRemainderSequence} constructor.
 
      if R has GcdDomain
@@ -51059,8 +51192,9 @@ These exports come from \refto{Field}():
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{UnivariateLaurentSeriesCategory} is the category of
-++   Laurent series in one variable.
+++ \spadtype{UnivariateLaurentSeriesCategory} is the category of
+++ Laurent series in one variable.
+
 UnivariateLaurentSeriesCategory(Coef): Category == Definition where
   Coef  : Ring
   I    ==> Integer
@@ -51531,8 +51665,9 @@ These exports come from \refto{RadicalCategory}():
 ++ Examples:
 ++ References:
 ++ Description:
-++   \spadtype{UnivariatePuiseuxSeriesCategory} is the category of Puiseux
-++   series in one variable.
+++ \spadtype{UnivariatePuiseuxSeriesCategory} is the category of Puiseux
+++ series in one variable.
+
 UnivariatePuiseuxSeriesCategory(Coef): Category == Definition where
   Coef : Ring
   NNI  ==> NonNegativeInteger
@@ -52181,7 +52316,7 @@ UnivariatePolynomialCategory(R:Ring): Category ==
       ++ unmakeSUP(sup) converts sup of type 
       ++ \spadtype{SparseUnivariatePolynomial(R)}
       ++ to be a member of the given type.
-      ++ Note: converse of makeSUP.
+      ++ Note that converse of makeSUP.
     multiplyExponents: (%,NonNegativeInteger) -> %
       ++ multiplyExponents(p,n) returns a new polynomial resulting from
       ++ multiplying all exponents of the polynomial p by the non negative
@@ -53036,9 +53171,10 @@ where R:Join(OrderedSet, IntegralDomain)):
 ++ Author: Manuel Bronstein
 ++ Date Created: 31 October 1988
 ++ Date Last Updated: 7 October 1991
-++ Description:
-++   Model for algebraically closed function spaces.
 ++ Keywords: algebraic, closure, field.
+++ Description:
+++ Model for algebraically closed function spaces.
+
 AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)):
  Category == Join(AlgebraicallyClosedField, FunctionSpace R) with
    rootOf : $ -> $
@@ -53046,7 +53182,7 @@ AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)):
      ++ Error: if p has more than one variable y.
    rootsOf: $ -> List $
      ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0};
-     ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+     ++ Note that the returned symbols y1,...,yn are bound in the interpreter
      ++ to respective root values.
      ++ Error: if p has more than one variable y.
    rootOf : ($, Symbol) -> $
@@ -53055,7 +53191,7 @@ AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)):
    rootsOf: ($, Symbol) -> List $
      ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0};
      ++ The returned roots display as \spad{'y1},...,\spad{'yn}.
-     ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+     ++ Note that the returned symbols y1,...,yn are bound in the interpreter
      ++ to respective root values.
    zeroOf : $ -> $
      ++ zeroOf(p) returns y such that \spad{p(y) = 0}.
@@ -53422,8 +53558,8 @@ These exports come from \refto{FieldOfPrimeCharacteristic}():
 ++  J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM.
 ++  AXIOM Technical Report Series, ATR/5 NP2522.
 ++ Description:
-++  ExtensionField {\em F} is the category of fields which extend
-++  the field F
+++ ExtensionField F is the category of fields which extend the field F
+
 ExtensionField(F:Field) : Category  == _
   Join(Field,RetractableTo F,VectorSpace F) with
     if F has CharacteristicZero then CharacteristicZero
@@ -53754,14 +53890,14 @@ These exports come from \refto{DifferentialRing}():
 ++  J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM.
 ++  AXIOM Technical Report Series, ATR/5 NP2522.
 ++ Description:
-++  FiniteFieldCategory is the category of finite fields
+++ 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.
+      ++ charthRoot(a) takes the characteristic'th root of a.
+      ++ Note that 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
@@ -53803,7 +53939,7 @@ FiniteFieldCategory() : Category ==_
       ++ 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.
+      ++ Implementation Note that 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.
@@ -54285,12 +54421,10 @@ These exports come from \refto{RealNumberSystem}():
 ++ exactly representable by floating point numbers.
 ++ A floating point system is characterized by the following:
 ++
-++   1: \spadfunFrom{base}{FloatingPointSystem} of the 
-++      \spadfunFrom{exponent}{FloatingPointSystem}.
-++      (actual implemenations are usually binary or decimal)
-++   2: \spadfunFrom{precision}{FloatingPointSystem} of the 
-++       \spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed)
-++   3: rounding error for operations
+++ 1: base of the exponent where the actual implemenations are 
+++ usually binary or decimal)\br
+++ 2: precision of the mantissa (arbitrary or fixed)\br
+++ 3: rounding error for operations
 --++   4:  when, and what happens if exponent overflow/underflow occurs
 ++
 ++ Because a Float is an approximation to the real numbers, even though
@@ -54298,6 +54432,7 @@ These exports come from \refto{RealNumberSystem}():
 ++ the attributes do not hold.  In particular associative("+")
 ++ does not hold.  Algorithms defined over a field need special
 ++ considerations when the field is a floating point system.
+
 FloatingPointSystem(): Category == RealNumberSystem() with
    approximate
       ++ \spad{approximate} means "is an approximation to the real numbers".
@@ -54307,7 +54442,7 @@ FloatingPointSystem(): Category == RealNumberSystem() with
       ++ float(a,e,b) returns \spad{a * b ** e}.
    order: % -> Integer
       ++ order x is the order of magnitude of x.
-      ++ Note: \spad{base ** order x <= |x| < base ** (1 + order x)}.
+      ++ Note that \spad{base ** order x <= |x| < base ** (1 + order x)}.
    base: () -> PositiveInteger
       ++ base() returns the base of the 
       ++\spadfunFrom{exponent}{FloatingPointSystem}.
@@ -55201,11 +55336,12 @@ where UTS:UnivariateLaurentSeriesCategory(Coef:Ring)
 ++ Examples:
 ++ References:
 ++ Description:
-++   This is a category of univariate Laurent series constructed from
-++   univariate Taylor series.  A Laurent series is represented by a pair
-++   \spad{[n,f(x)]}, where n is an arbitrary integer and \spad{f(x)}
-++   is a Taylor series.  This pair represents the Laurent series
-++   \spad{x**n * f(x)}.
+++ This is a category of univariate Laurent series constructed from
+++ univariate Taylor series.  A Laurent series is represented by a pair
+++ \spad{[n,f(x)]}, where n is an arbitrary integer and \spad{f(x)}
+++ is a Taylor series.  This pair represents the Laurent series
+++ \spad{x**n * f(x)}.
+
 UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_
  Category == Definition where
   Coef: Ring
@@ -55231,7 +55367,7 @@ UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_
       ++ 'leading zero' is removed from the Laurent series as follows:
       ++ the series is rewritten by increasing the exponent by 1 and
       ++ dividing the Taylor series by its variable.
-      ++ Note: \spad{removeZeroes(f)} removes all leading zeroes from f
+      ++ Note that \spad{removeZeroes(f)} removes all leading zeroes from f
     removeZeroes: (I,%) -> %
       ++ \spad{removeZeroes(n,f(x))} removes up to n leading zeroes from
       ++ the Laurent series \spad{f(x)}.
@@ -55674,11 +55810,12 @@ These exports come from \refto{UnivariatePuiseuxSeriesCategory}(Coef:Ring):
 ++ Examples:
 ++ References:
 ++ Description:
-++   This is a category of univariate Puiseux series constructed
-++   from univariate Laurent series.  A Puiseux series is represented
-++   by a pair \spad{[r,f(x)]}, where r is a positive rational number and
-++   \spad{f(x)} is a Laurent series.  This pair represents the Puiseux
-++   series \spad{f(x^r)}.
+++ This is a category of univariate Puiseux series constructed
+++ from univariate Laurent series.  A Puiseux series is represented
+++ by a pair \spad{[r,f(x)]}, where r is a positive rational number and
+++ \spad{f(x)} is a Laurent series.  This pair represents the Puiseux
+++ series \spad{f(x^r)}.
+
 UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS):_
  Category == Definition where
   Coef : Ring
@@ -56086,29 +56223,29 @@ These exports come from \refto{FiniteFieldCategory}():
 ++  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 is the category of fields
+++ which are finite algebraic extensions of the field F.
+++ If F is finite then any finite algebraic extension of F 
+++ is finite, too. Let K be a finite algebraic extension of the 
+++ finite field F. The exponentiation of elements of K 
+++ defines a Z-module structure on the multiplicative group of K. 
+++ The additive group of K becomes a module over the ring of 
+++ polynomials over F via the operation 
+++ \spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial F)
+++ which is linear over F, i.e. for elements a from K,
+++ c,d from F and f,g univariate polynomials over F
+++ we have \spadfun{linearAssociatedExp}(a,cf+dg) equals c times
+++ \spadfun{linearAssociatedExp}(a,f) plus d times
+++ \spadfun{linearAssociatedExp}(a,g).
+++ Therefore \spadfun{linearAssociatedExp} is defined completely by
+++ its action on  monomials from F[X]:
+++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is defined to be
+++ \spadfun{Frobenius}(a,k) which is a**(q**k) where 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
@@ -56156,12 +56293,13 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _
         ++ 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])
+        ++ Note that 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])}.
+        ++ Note that 
+        ++ \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,
@@ -56188,28 +56326,28 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _
         ++ 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
+        ++ linearAssociatedExp(a,f) is linear over F, i.e.
+        ++ for elements a from \$, c,d form F and
+        ++ f,g univariate polynomials over F we have
+        ++ \spadfun{linearAssociatedExp}(a,cf+dg) equals c times
+        ++ \spadfun{linearAssociatedExp}(a,f) plus d times
         ++ \spadfun{linearAssociatedExp}(a,g). Therefore
         ++ \spadfun{linearAssociatedExp} is defined completely by its 
-        ++ action on monomials from {\em F[X]}:
+        ++ action on monomials from 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}.
+        ++ defined to be \spadfun{Frobenius}(a,k) which is a**(q**k),
+        ++ where q=size()\$F.
       linearAssociatedOrder: $ -> SparseUnivariatePolynomial F
-        ++ linearAssociatedOrder(a) retruns the monic polynomial {\em g} of
+        ++ linearAssociatedOrder(a) retruns the monic polynomial 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(a) returns a polynomial g, such that
+        ++ \spadfun{linearAssociatedExp}(normalElement(),g) equals 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
+        ++ linearAssociatedLog(b,a) returns a polynomial g, such 
+        ++ that the \spadfun{linearAssociatedExp}(b,g) equals a.
+        ++ If there is no such polynomial g, then
         ++ \spadfun{linearAssociatedLog} fails.
   add
     I   ==> Integer
@@ -57354,7 +57492,8 @@ These exports come from \refto{TranscendentalFunctionCategory}():
 
 These exports come from \refto{PolynomialFactorizationExplicit}():
 \begin{verbatim}
- squareFreePolynomial : SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has EUCDOM and R has PFECAT
+ squareFreePolynomial : SparseUnivariatePolynomial % -> 
+   Factored SparseUnivariatePolynomial % if R has EUCDOM and R has PFECAT
 \end{verbatim}
 
 <<category COMPCAT ComplexCategory>>=
@@ -57369,8 +57508,8 @@ These exports come from \refto{PolynomialFactorizationExplicit}():
 ++ Keywords: complex, gaussian
 ++ References:
 ++ Description:
-++ This category represents the extension of a ring by a square
-++ root of -1.
+++ This category represents the extension of a ring by a square root of -1.
+
 ComplexCategory(R:CommutativeRing): Category ==
   Join(MonogenicAlgebra(R, SparseUnivariatePolynomial R), FullyRetractableTo R,
    DifferentialExtension R, FullyEvalableOver R, FullyPatternMatchable(R),
@@ -58382,9 +58521,11 @@ UPUP:UnivariatePolynomialCategory Fraction UP
 ++ Author: Manuel Bronstein
 ++ Date Created: 1987
 ++ Date Last Updated: 19 Mai 1993
-++ Description: This category is a model for the function field of a
-++ plane algebraic curve.
 ++ Keywords: algebraic, curve, function, field.
+++ Description:
+++ This category is a model for the function field of a
+++ plane algebraic curve.
+
 FunctionFieldCategory(F, UP, UPUP): Category == Definition where
   F   : UniqueFactorizationDomain
   UP  : UnivariatePolynomialCategory F
diff --git a/books/bookvol10.3.pamphlet b/books/bookvol10.3.pamphlet
index 1ce747d..a46e99a 100644
--- a/books/bookvol10.3.pamphlet
+++ b/books/bookvol10.3.pamphlet
@@ -403,14 +403,15 @@ in the bootstrap set. Thus,
 ++  R.D. Schafer: An Introduction to Nonassociative Algebras
 ++  Academic Press, New York, 1966
 ++ Description:
-++  AlgebraGivenByStructuralConstants implements finite rank algebras
-++  over a commutative ring, given by the structural constants \spad{gamma}
-++  with respect to a fixed  basis \spad{[a1,..,an]}, where
-++  \spad{gamma} is an \spad{n}-vector of n by n matrices
-++  \spad{[(gammaijk) for k in 1..rank()]} defined by
-++  \spad{ai * aj = gammaij1 * a1 + ... + gammaijn * an}.
-++  The symbols for the fixed basis
-++  have to be given as a list of symbols.
+++ AlgebraGivenByStructuralConstants implements finite rank algebras
+++ over a commutative ring, given by the structural constants \spad{gamma}
+++ with respect to a fixed  basis \spad{[a1,..,an]}, where
+++ \spad{gamma} is an \spad{n}-vector of n by n matrices
+++ \spad{[(gammaijk) for k in 1..rank()]} defined by
+++ \spad{ai * aj = gammaij1 * a1 + ... + gammaijn * an}.
+++ The symbols for the fixed basis
+++ have to be given as a list of symbols.
+
 AlgebraGivenByStructuralConstants(R:Field, n : PositiveInteger,_
   ls : List Symbol, gamma: Vector Matrix R ): public == private where
 
@@ -911,13 +912,13 @@ AlgebraGivenByStructuralConstants(R:Field, n : PositiveInteger,_
 
 <<domain ALGFF AlgebraicFunctionField>>=
 )abbrev domain ALGFF AlgebraicFunctionField
-++ Function field defined by f(x, y) = 0
 ++ Author: Manuel Bronstein
 ++ Date Created: 3 May 1988
 ++ Date Last Updated: 24 Jul 1990
 ++ Keywords: algebraic, curve, function, field.
-++ Description: Function field defined by f(x, y) = 0.
-++ Examples: )r ALGFF INPUT
+++ Description:
+++ Function field defined by f(x, y) = 0.
+
 AlgebraicFunctionField(F, UP, UPUP, modulus): Exports == Impl where
   F      : Field
   UP     : UnivariatePolynomialCategory F
@@ -934,7 +935,7 @@ AlgebraicFunctionField(F, UP, UPUP, modulus): Exports == Impl where
 
   Exports ==> FunctionFieldCategory(F, UP, UPUP) with
     knownInfBasis: N -> Void
-	++ knownInfBasis(n) \undocumented{}
+        ++ knownInfBasis(n) is not documented
 
   Impl ==> SAE add
     import ChangeOfVariable(F, UP, UPUP)
@@ -1152,12 +1153,13 @@ AlgebraicFunctionField(F, UP, UPUP, modulus): Exports == Impl where
 
 <<domain AN AlgebraicNumber>>=
 )abbrev domain AN AlgebraicNumber
-++ Algebraic closure of the rational numbers
 ++ Author: James Davenport
 ++ Date Created: 9 October 1995
 ++ Date Last Updated: 10 October 1995 (JHD)
-++ Description: Algebraic closure of the rational numbers, with mathematical =
 ++ Keywords: algebraic, number.
+++ Description:
+++ Algebraic closure of the rational numbers, with mathematical =
+
 AlgebraicNumber(): Exports == Implementation where
   Z   ==> Integer
   P   ==> SparseMultivariatePolynomial(Z, Kernel %)
@@ -1222,8 +1224,10 @@ AlgebraicNumber(): Exports == Implementation where
 
 <<domain ANON AnonymousFunction>>=
 )abbrev domain ANON AnonymousFunction
+++ Author: Mark Botch
 ++ Description:
 ++ This domain implements anonymous functions
+
 AnonymousFunction():SetCategory == add
   coerce(x:%):OutputForm == x pretend OutputForm
 
@@ -1283,16 +1287,11 @@ AnonymousFunction():SetCategory == add
 
 <<domain ANTISYM AntiSymm>>=
 )abbrev domain ANTISYM AntiSymm
-++   Author: Larry A. Lambe
-++   Date     : 01/26/91.
-++   Revised  : 30 Nov 94
-++
-++   based on AntiSymmetric '89
-++
-++   Needs: ExtAlgBasis, FreeModule(Ring,OrderedSet), LALG, LALG-
-++
-++   Description: The domain of antisymmetric polynomials.
- 
+++ Author: Larry A. Lambe
+++ Date     : 01/26/91.
+++ Revised  : 30 Nov 94
+++ Description:
+++ The domain of antisymmetric polynomials.
  
 AntiSymm(R:Ring, lVar:List Symbol): Export == Implement where
   LALG ==> LeftAlgebra
@@ -1309,37 +1308,37 @@ AntiSymm(R:Ring, lVar:List Symbol): Export == Implement where
  
   Export == Join(LALG(R), RetractableTo(R)) with
       leadingCoefficient : %           -> R
-	++ leadingCoefficient(p) returns the leading
-	++ coefficient of antisymmetric polynomial p.
+        ++ leadingCoefficient(p) returns the leading
+        ++ coefficient of antisymmetric polynomial p.
 --    leadingSupport       : %           -> EAB
       leadingBasisTerm     : %           -> %
-	++ leadingBasisTerm(p) returns the leading
-	++ basis term of antisymmetric polynomial p.
+        ++ leadingBasisTerm(p) returns the leading
+        ++ basis term of antisymmetric polynomial p.
       reductum           : %           -> %
-	++ reductum(p), where p is an antisymmetric polynomial,
+        ++ reductum(p), where p is an antisymmetric polynomial,
         ++ returns p minus the leading
-	++ term of p if p has at least two terms, and 0 otherwise.
+        ++ term of p if p has at least two terms, and 0 otherwise.
       coefficient        : (%,%)     -> R 
-	++ coefficient(p,u) returns the coefficient of 
-	++ the term in p containing the basis term u if such 
+        ++ coefficient(p,u) returns the coefficient of 
+        ++ the term in p containing the basis term u if such 
         ++ a term exists, and 0 otherwise.
-	++ Error: if the second argument u is not a basis element.
+        ++ Error: if the second argument u is not a basis element.
       generator          : NNI         -> %
-	++ generator(n) returns the nth multiplicative generator,
-	++ a basis term.
+        ++ generator(n) returns the nth multiplicative generator,
+        ++ a basis term.
       exp                : L I         -> %
-	++  exp([i1,...in]) returns \spad{u_1\^{i_1} ... u_n\^{i_n}}
+        ++  exp([i1,...in]) returns \spad{u_1\^{i_1} ... u_n\^{i_n}}
       homogeneous?       : %           -> Boolean
-	++  homogeneous?(p) tests if all of the terms of 
-	++  p have the same degree.
+        ++  homogeneous?(p) tests if all of the terms of 
+        ++  p have the same degree.
       retractable?       : %           -> Boolean
-	++  retractable?(p) tests if p is a 0-form,
-	++  i.e., if degree(p) = 0.
+        ++  retractable?(p) tests if p is a 0-form,
+        ++  i.e., if degree(p) = 0.
       degree             : %           -> NNI
-	++  degree(p) returns the homogeneous degree of p.
+        ++  degree(p) returns the homogeneous degree of p.
       map                : (R -> R, %) -> %
-	++  map(f,p) changes each coefficient of p by the
-	++  application of f.
+        ++  map(f,p) changes each coefficient of p by the
+        ++  application of f.
 
 
 --    1 corresponds to the empty monomial Nul = [0,...,0]
@@ -1762,13 +1761,13 @@ o )show Any
 ++ AMS Classification:
 ++ Keywords:
 ++ Description:
-++   \spadtype{Any} implements a type that packages up objects and their
-++   types in objects of \spadtype{Any}. Roughly speaking that means
-++   that if \spad{s : S} then when converted to \spadtype{Any}, the new
-++   object will include both the original object and its type. This is
-++   a way of converting arbitrary objects into a single type without
-++   losing any of the original information. Any object can be converted
-++   to one of \spadtype{Any}.
+++ \spadtype{Any} implements a type that packages up objects and their
+++ types in objects of \spadtype{Any}. Roughly speaking that means
+++ that if \spad{s : S} then when converted to \spadtype{Any}, the new
+++ object will include both the original object and its type. This is
+++ a way of converting arbitrary objects into a single type without
+++ losing any of the original information. Any object can be converted
+++ to one of \spadtype{Any}.
 
 Any(): SetCategory with
         any             : (SExpression, None) -> %
@@ -2524,7 +2523,6 @@ o )show BagAggregate
 ++ Examples:
 ++ References:
 ++ Description:
- 
 ++ A stack represented as a flexible array.
 --% Dequeue and Heap data types
  
@@ -2728,21 +2726,18 @@ ArrayStack(S:SetCategory): StackAggregate(S) with
 )abbrev domain ASP1 Asp1
 ++ Author: Mike Dewar, Grant Keady, Godfrey Nolan
 ++ Date Created: Mar 1993
-++ Date Last Updated: 18 March 1994
-++                     6 October 1994
+++ Date Last Updated: 18 March 1994, 6 October 1994
 ++ Related Constructors: FortranFunctionCategory, FortranProgramCategory.
-++ Description: 
+++ Description:
 ++ \spadtype{Asp1} produces Fortran for Type 1 ASPs, needed for various
-++ NAG routines. Type 1 ASPs take a univariate expression (in the symbol
-++ X) and turn it into a Fortran Function like the following:
-++\begin{verbatim}
-++      DOUBLE PRECISION FUNCTION F(X)
-++      DOUBLE PRECISION X
-++      F=DSIN(X)
-++      RETURN
-++      END
-++\end{verbatim}
-
+++ NAG routines. Type 1 ASPs take a univariate expression (in the symbol x)
+++ and turn it into a Fortran Function like the following:
+++
+++ \tab{5}DOUBLE PRECISION FUNCTION F(X)\br
+++ \tab{5}DOUBLE PRECISION X\br
+++ \tab{5}F=DSIN(X)\br
+++ \tab{5}RETURN\br
+++ \tab{5}END
 
 Asp1(name): Exports == Implementation where
   name : Symbol
@@ -2858,18 +2853,17 @@ Asp1(name): Exports == Implementation where
 ++                     6 October 1994
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description: 
-++\spadtype{ASP10} produces Fortran for Type 10 ASPs, needed for NAG routine 
-++\axiomOpFrom{d02kef}{d02Package}. This ASP computes the values of a set of functions, for example: 
-++\begin{verbatim}
-++      SUBROUTINE COEFFN(P,Q,DQDL,X,ELAM,JINT)
-++      DOUBLE PRECISION ELAM,P,Q,X,DQDL
-++      INTEGER JINT
-++      P=1.0D0
-++      Q=((-1.0D0*X**3)+ELAM*X*X-2.0D0)/(X*X)
-++      DQDL=1.0D0
-++      RETURN
-++      END
-++\end{verbatim}
+++ \spadtype{ASP10} produces Fortran for Type 10 ASPs, needed for NAG routine 
+++ d02kef. This ASP computes the values of a set of functions, for example: 
+++
+++ \tab{5}SUBROUTINE COEFFN(P,Q,DQDL,X,ELAM,JINT)\br
+++ \tab{5}DOUBLE PRECISION ELAM,P,Q,X,DQDL\br
+++ \tab{5}INTEGER JINT\br
+++ \tab{5}P=1.0D0\br
+++ \tab{5}Q=((-1.0D0*X**3)+ELAM*X*X-2.0D0)/(X*X)\br
+++ \tab{5}DQDL=1.0D0\br
+++ \tab{5}RETURN\br
+++ \tab{5}END
 
 Asp10(name): Exports == Implementation where
   name : Symbol
@@ -3012,19 +3006,19 @@ Asp10(name): Exports == Implementation where
 ++                    21 June 1994 Changed print to printStatement
 ++ Related Constructors:
 ++ Description:
-++\spadtype{Asp12} produces Fortran for Type 12 ASPs, needed for NAG routine 
-++\axiomOpFrom{d02kef}{d02Package} etc., for example: 
-++\begin{verbatim}
-++      SUBROUTINE MONIT (MAXIT,IFLAG,ELAM,FINFO)
-++      DOUBLE PRECISION ELAM,FINFO(15)
-++      INTEGER MAXIT,IFLAG
-++      IF(MAXIT.EQ.-1)THEN
-++        PRINT*,"Output from Monit"
-++      ENDIF
-++      PRINT*,MAXIT,IFLAG,ELAM,(FINFO(I),I=1,4)
-++      RETURN
-++      END
-++\end{verbatim}
+++ \spadtype{Asp12} produces Fortran for Type 12 ASPs, needed for NAG routine 
+++ d02kef etc., for example: 
+++
+++ \tab{5}SUBROUTINE MONIT (MAXIT,IFLAG,ELAM,FINFO)\br
+++ \tab{5}DOUBLE PRECISION ELAM,FINFO(15)\br
+++ \tab{5}INTEGER MAXIT,IFLAG\br
+++ \tab{5}IF(MAXIT.EQ.-1)THEN\br
+++ \tab{7}PRINT*,"Output from Monit"\br
+++ \tab{5}ENDIF\br
+++ \tab{5}PRINT*,MAXIT,IFLAG,ELAM,(FINFO(I),I=1,4)\br
+++ \tab{5}RETURN\br
+++ \tab{5}END\
+
 Asp12(name): Exports == Implementation where
   name : Symbol
 
@@ -3099,111 +3093,110 @@ Asp12(name): Exports == Implementation where
 ++ Description:
 ++\spadtype{Asp19} produces Fortran for Type 19 ASPs, evaluating a set of
 ++functions and their jacobian at a given point, for example:
-++\begin{verbatim}
-++      SUBROUTINE LSFUN2(M,N,XC,FVECC,FJACC,LJC)
-++      DOUBLE PRECISION FVECC(M),FJACC(LJC,N),XC(N)
-++      INTEGER M,N,LJC
-++      INTEGER I,J
-++      DO 25003 I=1,LJC
-++        DO 25004 J=1,N
-++          FJACC(I,J)=0.0D0
-++25004   CONTINUE
-++25003 CONTINUE
-++      FVECC(1)=((XC(1)-0.14D0)*XC(3)+(15.0D0*XC(1)-2.1D0)*XC(2)+1.0D0)/(
-++     &XC(3)+15.0D0*XC(2))
-++      FVECC(2)=((XC(1)-0.18D0)*XC(3)+(7.0D0*XC(1)-1.26D0)*XC(2)+1.0D0)/(
-++     &XC(3)+7.0D0*XC(2))
-++      FVECC(3)=((XC(1)-0.22D0)*XC(3)+(4.333333333333333D0*XC(1)-0.953333
-++     &3333333333D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))
-++      FVECC(4)=((XC(1)-0.25D0)*XC(3)+(3.0D0*XC(1)-0.75D0)*XC(2)+1.0D0)/(
-++     &XC(3)+3.0D0*XC(2))
-++      FVECC(5)=((XC(1)-0.29D0)*XC(3)+(2.2D0*XC(1)-0.6379999999999999D0)*
-++     &XC(2)+1.0D0)/(XC(3)+2.2D0*XC(2))
-++      FVECC(6)=((XC(1)-0.32D0)*XC(3)+(1.666666666666667D0*XC(1)-0.533333
-++     &3333333333D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))
-++      FVECC(7)=((XC(1)-0.35D0)*XC(3)+(1.285714285714286D0*XC(1)-0.45D0)*
-++     &XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))
-++      FVECC(8)=((XC(1)-0.39D0)*XC(3)+(XC(1)-0.39D0)*XC(2)+1.0D0)/(XC(3)+
-++     &XC(2))
-++      FVECC(9)=((XC(1)-0.37D0)*XC(3)+(XC(1)-0.37D0)*XC(2)+1.285714285714
-++     &286D0)/(XC(3)+XC(2))
-++      FVECC(10)=((XC(1)-0.58D0)*XC(3)+(XC(1)-0.58D0)*XC(2)+1.66666666666
-++     &6667D0)/(XC(3)+XC(2))
-++      FVECC(11)=((XC(1)-0.73D0)*XC(3)+(XC(1)-0.73D0)*XC(2)+2.2D0)/(XC(3)
-++     &+XC(2))
-++      FVECC(12)=((XC(1)-0.96D0)*XC(3)+(XC(1)-0.96D0)*XC(2)+3.0D0)/(XC(3)
-++     &+XC(2))
-++      FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333
-++     &3333D0)/(XC(3)+XC(2))
-++      FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X
-++     &C(2))
-++      FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3
-++     &)+XC(2))
-++      FJACC(1,1)=1.0D0
-++      FJACC(1,2)=-15.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)
-++      FJACC(1,3)=-1.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)
-++      FJACC(2,1)=1.0D0
-++      FJACC(2,2)=-7.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)
-++      FJACC(2,3)=-1.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)
-++      FJACC(3,1)=1.0D0
-++      FJACC(3,2)=((-0.1110223024625157D-15*XC(3))-4.333333333333333D0)/(
-++     &XC(3)**2+8.666666666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)
-++     &**2)
-++      FJACC(3,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+8.666666
-++     &666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)**2)
-++      FJACC(4,1)=1.0D0
-++      FJACC(4,2)=-3.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)
-++      FJACC(4,3)=-1.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)
-++      FJACC(5,1)=1.0D0
-++      FJACC(5,2)=((-0.1110223024625157D-15*XC(3))-2.2D0)/(XC(3)**2+4.399
-++     &999999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)
-++      FJACC(5,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+4.399999
-++     &999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)
-++      FJACC(6,1)=1.0D0
-++      FJACC(6,2)=((-0.2220446049250313D-15*XC(3))-1.666666666666667D0)/(
-++     &XC(3)**2+3.333333333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)
-++     &**2)
-++      FJACC(6,3)=(0.2220446049250313D-15*XC(2)-1.0D0)/(XC(3)**2+3.333333
-++     &333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)**2)
-++      FJACC(7,1)=1.0D0
-++      FJACC(7,2)=((-0.5551115123125783D-16*XC(3))-1.285714285714286D0)/(
-++     &XC(3)**2+2.571428571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)
-++     &**2)
-++      FJACC(7,3)=(0.5551115123125783D-16*XC(2)-1.0D0)/(XC(3)**2+2.571428
-++     &571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)**2)
-++      FJACC(8,1)=1.0D0
-++      FJACC(8,2)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(8,3)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(9,1)=1.0D0
-++      FJACC(9,2)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*
-++     &*2)
-++      FJACC(9,3)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*
-++     &*2)
-++      FJACC(10,1)=1.0D0
-++      FJACC(10,2)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)
-++     &**2)
-++      FJACC(10,3)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)
-++     &**2)
-++      FJACC(11,1)=1.0D0
-++      FJACC(11,2)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(11,3)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(12,1)=1.0D0
-++      FJACC(12,2)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(12,3)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(13,1)=1.0D0
-++      FJACC(13,2)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)
-++     &**2)
-++      FJACC(13,3)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)
-++     &**2)
-++      FJACC(14,1)=1.0D0
-++      FJACC(14,2)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(14,3)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(15,1)=1.0D0
-++      FJACC(15,2)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      FJACC(15,3)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)
-++      RETURN
-++      END
-++\end{verbatim}
+++
+++\tab{5}SUBROUTINE LSFUN2(M,N,XC,FVECC,FJACC,LJC)\br
+++\tab{5}DOUBLE PRECISION FVECC(M),FJACC(LJC,N),XC(N)\br
+++\tab{5}INTEGER M,N,LJC\br
+++\tab{5}INTEGER I,J\br
+++\tab{5}DO 25003 I=1,LJC\br
+++\tab{7}DO 25004 J=1,N\br
+++\tab{9}FJACC(I,J)=0.0D0\br
+++25004   CONTINUE\br
+++25003 CONTINUE\br
+++\tab{5}FVECC(1)=((XC(1)-0.14D0)*XC(3)+(15.0D0*XC(1)-2.1D0)*XC(2)+1.0D0)/(\br
+++\tab{4}&XC(3)+15.0D0*XC(2))\br
+++\tab{5}FVECC(2)=((XC(1)-0.18D0)*XC(3)+(7.0D0*XC(1)-1.26D0)*XC(2)+1.0D0)/(\br
+++\tab{4}&XC(3)+7.0D0*XC(2))\br
+++\tab{5}FVECC(3)=((XC(1)-0.22D0)*XC(3)+(4.333333333333333D0*XC(1)-0.953333\br
+++\tab{4}&3333333333D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))\br
+++\tab{5}FVECC(4)=((XC(1)-0.25D0)*XC(3)+(3.0D0*XC(1)-0.75D0)*XC(2)+1.0D0)/(\br
+++\tab{4}&XC(3)+3.0D0*XC(2))\br
+++\tab{5}FVECC(5)=((XC(1)-0.29D0)*XC(3)+(2.2D0*XC(1)-0.6379999999999999D0)*\br
+++\tab{4}&XC(2)+1.0D0)/(XC(3)+2.2D0*XC(2))\br
+++\tab{5}FVECC(6)=((XC(1)-0.32D0)*XC(3)+(1.666666666666667D0*XC(1)-0.533333\br
+++\tab{4}&3333333333D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))\br
+++\tab{5}FVECC(7)=((XC(1)-0.35D0)*XC(3)+(1.285714285714286D0*XC(1)-0.45D0)*\br
+++\tab{4}&XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))\br
+++\tab{5}FVECC(8)=((XC(1)-0.39D0)*XC(3)+(XC(1)-0.39D0)*XC(2)+1.0D0)/(XC(3)+\br
+++\tab{4}&XC(2))\br
+++\tab{5}FVECC(9)=((XC(1)-0.37D0)*XC(3)+(XC(1)-0.37D0)*XC(2)+1.285714285714\br
+++\tab{4}&286D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(10)=((XC(1)-0.58D0)*XC(3)+(XC(1)-0.58D0)*XC(2)+1.66666666666\br
+++\tab{4}&6667D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(11)=((XC(1)-0.73D0)*XC(3)+(XC(1)-0.73D0)*XC(2)+2.2D0)/(XC(3)\br
+++\tab{4}&+XC(2))\br
+++\tab{5}FVECC(12)=((XC(1)-0.96D0)*XC(3)+(XC(1)-0.96D0)*XC(2)+3.0D0)/(XC(3)\br
+++\tab{4}&+XC(2))\br
+++\tab{5}FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333\br
+++\tab{4}&3333D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X\br
+++\tab{4}&C(2))\br
+++\tab{5}FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3\br
+++\tab{4}&)+XC(2))\br
+++\tab{5}FJACC(1,1)=1.0D0\br
+++\tab{5}FJACC(1,2)=-15.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)\br
+++\tab{5}FJACC(1,3)=-1.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)\br
+++\tab{5}FJACC(2,1)=1.0D0\br
+++\tab{5}FJACC(2,2)=-7.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)\br
+++\tab{5}FJACC(2,3)=-1.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)\br
+++\tab{5}FJACC(3,1)=1.0D0\br
+++\tab{5}FJACC(3,2)=((-0.1110223024625157D-15*XC(3))-4.333333333333333D0)/(\br
+++\tab{4}&XC(3)**2+8.666666666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(3,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+8.666666\br
+++\tab{4}&666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)**2)\br
+++\tab{5}FJACC(4,1)=1.0D0\br
+++\tab{5}FJACC(4,2)=-3.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)\br
+++\tab{5}FJACC(4,3)=-1.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)\br
+++\tab{5}FJACC(5,1)=1.0D0\br
+++\tab{5}FJACC(5,2)=((-0.1110223024625157D-15*XC(3))-2.2D0)/(XC(3)**2+4.399\br
+++\tab{4}&999999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)\br
+++\tab{5}FJACC(5,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+4.399999\br
+++\tab{4}&999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)\br
+++\tab{5}FJACC(6,1)=1.0D0\br
+++\tab{5}FJACC(6,2)=((-0.2220446049250313D-15*XC(3))-1.666666666666667D0)/(\br
+++\tab{4}&XC(3)**2+3.333333333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(6,3)=(0.2220446049250313D-15*XC(2)-1.0D0)/(XC(3)**2+3.333333\br
+++\tab{4}&333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)**2)\br
+++\tab{5}FJACC(7,1)=1.0D0\br
+++\tab{5}FJACC(7,2)=((-0.5551115123125783D-16*XC(3))-1.285714285714286D0)/(\br
+++\tab{4}&XC(3)**2+2.571428571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(7,3)=(0.5551115123125783D-16*XC(2)-1.0D0)/(XC(3)**2+2.571428\br
+++\tab{4}&571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)**2)\br
+++\tab{5}FJACC(8,1)=1.0D0\br
+++\tab{5}FJACC(8,2)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(8,3)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(9,1)=1.0D0\br
+++\tab{5}FJACC(9,2)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*\br
+++\tab{4}&*2)\br
+++\tab{5}FJACC(9,3)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*\br
+++\tab{4}&*2)\br
+++\tab{5}FJACC(10,1)=1.0D0\br
+++\tab{5}FJACC(10,2)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(10,3)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(11,1)=1.0D0\br
+++\tab{5}FJACC(11,2)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(11,3)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(12,1)=1.0D0\br
+++\tab{5}FJACC(12,2)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(12,3)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(13,1)=1.0D0\br
+++\tab{5}FJACC(13,2)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(13,3)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br
+++\tab{4}&**2)\br
+++\tab{5}FJACC(14,1)=1.0D0\br
+++\tab{5}FJACC(14,2)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(14,3)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(15,1)=1.0D0\br
+++\tab{5}FJACC(15,2)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}FJACC(15,3)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp19(name): Exports == Implementation where
   name : Symbol
@@ -3387,21 +3380,20 @@ Asp19(name): Exports == Implementation where
 ++                     6 October 1994
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description:
-++\spadtype{Asp20} produces Fortran for Type 20 ASPs, for example:
-++\begin{verbatim}
-++      SUBROUTINE QPHESS(N,NROWH,NCOLH,JTHCOL,HESS,X,HX)
-++      DOUBLE PRECISION HX(N),X(N),HESS(NROWH,NCOLH)
-++      INTEGER JTHCOL,N,NROWH,NCOLH
-++      HX(1)=2.0D0*X(1)
-++      HX(2)=2.0D0*X(2)
-++      HX(3)=2.0D0*X(4)+2.0D0*X(3)
-++      HX(4)=2.0D0*X(4)+2.0D0*X(3)
-++      HX(5)=2.0D0*X(5)
-++      HX(6)=(-2.0D0*X(7))+(-2.0D0*X(6))
-++      HX(7)=(-2.0D0*X(7))+(-2.0D0*X(6))
-++      RETURN
-++      END
-++\end{verbatim}
+++ \spadtype{Asp20} produces Fortran for Type 20 ASPs, for example:
+++
+++ \tab{5}SUBROUTINE QPHESS(N,NROWH,NCOLH,JTHCOL,HESS,X,HX)\br
+++ \tab{5}DOUBLE PRECISION HX(N),X(N),HESS(NROWH,NCOLH)\br
+++ \tab{5}INTEGER JTHCOL,N,NROWH,NCOLH\br
+++ \tab{5}HX(1)=2.0D0*X(1)\br
+++ \tab{5}HX(2)=2.0D0*X(2)\br
+++ \tab{5}HX(3)=2.0D0*X(4)+2.0D0*X(3)\br
+++ \tab{5}HX(4)=2.0D0*X(4)+2.0D0*X(3)\br
+++ \tab{5}HX(5)=2.0D0*X(5)\br
+++ \tab{5}HX(6)=(-2.0D0*X(7))+(-2.0D0*X(6))\br
+++ \tab{5}HX(7)=(-2.0D0*X(7))+(-2.0D0*X(6))\br
+++ \tab{5}RETURN\br
+++ \tab{5}END
 
 Asp20(name): Exports == Implementation where
   name : Symbol
@@ -3570,19 +3562,19 @@ Asp20(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp24} produces Fortran for Type 24 ASPs which evaluate a 
-++multivariate function at a point (needed for NAG routine \axiomOpFrom{e04jaf}{e04Package}), for example:
-++\begin{verbatim}
-++      SUBROUTINE FUNCT1(N,XC,FC)
-++      DOUBLE PRECISION FC,XC(N)
-++      INTEGER N
-++      FC=10.0D0*XC(4)**4+(-40.0D0*XC(1)*XC(4)**3)+(60.0D0*XC(1)**2+5
-++     &.0D0)*XC(4)**2+((-10.0D0*XC(3))+(-40.0D0*XC(1)**3))*XC(4)+16.0D0*X
-++     &C(3)**4+(-32.0D0*XC(2)*XC(3)**3)+(24.0D0*XC(2)**2+5.0D0)*XC(3)**2+
-++     &(-8.0D0*XC(2)**3*XC(3))+XC(2)**4+100.0D0*XC(2)**2+20.0D0*XC(1)*XC(
-++     &2)+10.0D0*XC(1)**4+XC(1)**2
-++      RETURN
-++      END
-++\end{verbatim}
+++multivariate function at a point (needed for NAG routine e04jaf), 
+++for example:
+++
+++\tab{5}SUBROUTINE FUNCT1(N,XC,FC)\br
+++\tab{5}DOUBLE PRECISION FC,XC(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}FC=10.0D0*XC(4)**4+(-40.0D0*XC(1)*XC(4)**3)+(60.0D0*XC(1)**2+5\br
+++\tab{4}&.0D0)*XC(4)**2+((-10.0D0*XC(3))+(-40.0D0*XC(1)**3))*XC(4)+16.0D0*X\br
+++\tab{4}&C(3)**4+(-32.0D0*XC(2)*XC(3)**3)+(24.0D0*XC(2)**2+5.0D0)*XC(3)**2+\br
+++\tab{4}&(-8.0D0*XC(2)**3*XC(3))+XC(2)**4+100.0D0*XC(2)**2+20.0D0*XC(1)*XC(\br
+++\tab{4}&2)+10.0D0*XC(1)**4+XC(1)**2\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
 
 Asp24(name): Exports == Implementation where
   name : Symbol
@@ -3601,8 +3593,8 @@ Asp24(name): Exports == Implementation where
 
   Exports ==> FortranFunctionCategory with
       coerce : FEXPR -> $
-	++ coerce(f) takes an object from the appropriate instantiation of
-      	++ \spadtype{FortranExpression} and turns it into an ASP.
+        ++ coerce(f) takes an object from the appropriate instantiation of
+              ++ \spadtype{FortranExpression} and turns it into an ASP.
 
 
   Implementation ==> add
@@ -3701,24 +3693,23 @@ Asp24(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp27} produces Fortran for Type 27 ASPs, needed for NAG routine
-++\axiomOpFrom{f02fjf}{f02Package} ,for example:
-++\begin{verbatim}
-++      FUNCTION DOT(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)
-++      DOUBLE PRECISION W(N),Z(N),RWORK(LRWORK)
-++      INTEGER N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)
-++      DOT=(W(16)+(-0.5D0*W(15)))*Z(16)+((-0.5D0*W(16))+W(15)+(-0.5D0*W(1
-++     &4)))*Z(15)+((-0.5D0*W(15))+W(14)+(-0.5D0*W(13)))*Z(14)+((-0.5D0*W(
-++     &14))+W(13)+(-0.5D0*W(12)))*Z(13)+((-0.5D0*W(13))+W(12)+(-0.5D0*W(1
-++     &1)))*Z(12)+((-0.5D0*W(12))+W(11)+(-0.5D0*W(10)))*Z(11)+((-0.5D0*W(
-++     &11))+W(10)+(-0.5D0*W(9)))*Z(10)+((-0.5D0*W(10))+W(9)+(-0.5D0*W(8))
-++     &)*Z(9)+((-0.5D0*W(9))+W(8)+(-0.5D0*W(7)))*Z(8)+((-0.5D0*W(8))+W(7)
-++     &+(-0.5D0*W(6)))*Z(7)+((-0.5D0*W(7))+W(6)+(-0.5D0*W(5)))*Z(6)+((-0.
-++     &5D0*W(6))+W(5)+(-0.5D0*W(4)))*Z(5)+((-0.5D0*W(5))+W(4)+(-0.5D0*W(3
-++     &)))*Z(4)+((-0.5D0*W(4))+W(3)+(-0.5D0*W(2)))*Z(3)+((-0.5D0*W(3))+W(
-++     &2)+(-0.5D0*W(1)))*Z(2)+((-0.5D0*W(2))+W(1))*Z(1)
-++      RETURN
-++      END
-++\end{verbatim}
+++f02fjf ,for example:
+++
+++\tab{5}FUNCTION DOT(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)\br
+++\tab{5}DOUBLE PRECISION W(N),Z(N),RWORK(LRWORK)\br
+++\tab{5}INTEGER N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)\br
+++\tab{5}DOT=(W(16)+(-0.5D0*W(15)))*Z(16)+((-0.5D0*W(16))+W(15)+(-0.5D0*W(1\br
+++\tab{4}&4)))*Z(15)+((-0.5D0*W(15))+W(14)+(-0.5D0*W(13)))*Z(14)+((-0.5D0*W(\br
+++\tab{4}&14))+W(13)+(-0.5D0*W(12)))*Z(13)+((-0.5D0*W(13))+W(12)+(-0.5D0*W(1\br
+++\tab{4}&1)))*Z(12)+((-0.5D0*W(12))+W(11)+(-0.5D0*W(10)))*Z(11)+((-0.5D0*W(\br
+++\tab{4}&11))+W(10)+(-0.5D0*W(9)))*Z(10)+((-0.5D0*W(10))+W(9)+(-0.5D0*W(8))\br
+++\tab{4}&)*Z(9)+((-0.5D0*W(9))+W(8)+(-0.5D0*W(7)))*Z(8)+((-0.5D0*W(8))+W(7)\br
+++\tab{4}&+(-0.5D0*W(6)))*Z(7)+((-0.5D0*W(7))+W(6)+(-0.5D0*W(5)))*Z(6)+((-0.\br
+++\tab{4}&5D0*W(6))+W(5)+(-0.5D0*W(4)))*Z(5)+((-0.5D0*W(5))+W(4)+(-0.5D0*W(3\br
+++\tab{4}&)))*Z(4)+((-0.5D0*W(4))+W(3)+(-0.5D0*W(2)))*Z(3)+((-0.5D0*W(3))+W(\br
+++\tab{4}&2)+(-0.5D0*W(1)))*Z(2)+((-0.5D0*W(2))+W(1))*Z(1)\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp27(name): Exports == Implementation where
   name : Symbol
@@ -3814,140 +3805,139 @@ Asp27(name): Exports == Implementation where
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp28} produces Fortran for Type 28 ASPs, used in NAG routine 
-++\axiomOpFrom{f02fjf}{f02Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE IMAGE(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)
-++      DOUBLE PRECISION Z(N),W(N),IWORK(LRWORK),RWORK(LRWORK)
-++      INTEGER N,LIWORK,IFLAG,LRWORK
-++      W(1)=0.01707454969713436D0*Z(16)+0.001747395874954051D0*Z(15)+0.00
-++     &2106973900813502D0*Z(14)+0.002957434991769087D0*Z(13)+(-0.00700554
-++     &0882865317D0*Z(12))+(-0.01219194009813166D0*Z(11))+0.0037230647365
-++     &3087D0*Z(10)+0.04932374658377151D0*Z(9)+(-0.03586220812223305D0*Z(
-++     &8))+(-0.04723268012114625D0*Z(7))+(-0.02434652144032987D0*Z(6))+0.
-++     &2264766947290192D0*Z(5)+(-0.1385343580686922D0*Z(4))+(-0.116530050
-++     &8238904D0*Z(3))+(-0.2803531651057233D0*Z(2))+1.019463911841327D0*Z
-++     &(1)
-++      W(2)=0.0227345011107737D0*Z(16)+0.008812321197398072D0*Z(15)+0.010
-++     &94012210519586D0*Z(14)+(-0.01764072463999744D0*Z(13))+(-0.01357136
-++     &72105995D0*Z(12))+0.00157466157362272D0*Z(11)+0.05258889186338282D
-++     &0*Z(10)+(-0.01981532388243379D0*Z(9))+(-0.06095390688679697D0*Z(8)
-++     &)+(-0.04153119955569051D0*Z(7))+0.2176561076571465D0*Z(6)+(-0.0532
-++     &5555586632358D0*Z(5))+(-0.1688977368984641D0*Z(4))+(-0.32440166056
-++     &67343D0*Z(3))+0.9128222941872173D0*Z(2)+(-0.2419652703415429D0*Z(1
-++     &))
-++      W(3)=0.03371198197190302D0*Z(16)+0.02021603150122265D0*Z(15)+(-0.0
-++     &06607305534689702D0*Z(14))+(-0.03032392238968179D0*Z(13))+0.002033
-++     &305231024948D0*Z(12)+0.05375944956767728D0*Z(11)+(-0.0163213312502
-++     &9967D0*Z(10))+(-0.05483186562035512D0*Z(9))+(-0.04901428822579872D
-++     &0*Z(8))+0.2091097927887612D0*Z(7)+(-0.05760560341383113D0*Z(6))+(-
-++     &0.1236679206156403D0*Z(5))+(-0.3523683853026259D0*Z(4))+0.88929961
-++     &32269974D0*Z(3)+(-0.2995429545781457D0*Z(2))+(-0.02986582812574917
-++     &D0*Z(1))
-++      W(4)=0.05141563713660119D0*Z(16)+0.005239165960779299D0*Z(15)+(-0.
-++     &01623427735779699D0*Z(14))+(-0.01965809746040371D0*Z(13))+0.054688
-++     &97337339577D0*Z(12)+(-0.014224695935687D0*Z(11))+(-0.0505181779315
-++     &6355D0*Z(10))+(-0.04353074206076491D0*Z(9))+0.2012230497530726D0*Z
-++     &(8)+(-0.06630874514535952D0*Z(7))+(-0.1280829963720053D0*Z(6))+(-0
-++     &.305169742604165D0*Z(5))+0.8600427128450191D0*Z(4)+(-0.32415033802
-++     &68184D0*Z(3))+(-0.09033531980693314D0*Z(2))+0.09089205517109111D0*
-++     &Z(1)
-++      W(5)=0.04556369767776375D0*Z(16)+(-0.001822737697581869D0*Z(15))+(
-++     &-0.002512226501941856D0*Z(14))+0.02947046460707379D0*Z(13)+(-0.014
-++     &45079632086177D0*Z(12))+(-0.05034242196614937D0*Z(11))+(-0.0376966
-++     &3291725935D0*Z(10))+0.2171103102175198D0*Z(9)+(-0.0824949256021352
-++     &4D0*Z(8))+(-0.1473995209288945D0*Z(7))+(-0.315042193418466D0*Z(6))
-++     &+0.9591623347824002D0*Z(5)+(-0.3852396953763045D0*Z(4))+(-0.141718
-++     &5427288274D0*Z(3))+(-0.03423495461011043D0*Z(2))+0.319820917706851
-++     &6D0*Z(1)
-++      W(6)=0.04015147277405744D0*Z(16)+0.01328585741341559D0*Z(15)+0.048
-++     &26082005465965D0*Z(14)+(-0.04319641116207706D0*Z(13))+(-0.04931323
-++     &319055762D0*Z(12))+(-0.03526886317505474D0*Z(11))+0.22295383396730
-++     &01D0*Z(10)+(-0.07375317649315155D0*Z(9))+(-0.1589391311991561D0*Z(
-++     &8))+(-0.328001910890377D0*Z(7))+0.952576555482747D0*Z(6)+(-0.31583
-++     &09975786731D0*Z(5))+(-0.1846882042225383D0*Z(4))+(-0.0703762046700
-++     &4427D0*Z(3))+0.2311852964327382D0*Z(2)+0.04254083491825025D0*Z(1)
-++      W(7)=0.06069778964023718D0*Z(16)+0.06681263884671322D0*Z(15)+(-0.0
-++     &2113506688615768D0*Z(14))+(-0.083996867458326D0*Z(13))+(-0.0329843
-++     &8523869648D0*Z(12))+0.2276878326327734D0*Z(11)+(-0.067356038933017
-++     &95D0*Z(10))+(-0.1559813965382218D0*Z(9))+(-0.3363262957694705D0*Z(
-++     &8))+0.9442791158560948D0*Z(7)+(-0.3199955249404657D0*Z(6))+(-0.136
-++     &2463839920727D0*Z(5))+(-0.1006185171570586D0*Z(4))+0.2057504515015
-++     &423D0*Z(3)+(-0.02065879269286707D0*Z(2))+0.03160990266745513D0*Z(1
-++     &)
-++      W(8)=0.126386868896738D0*Z(16)+0.002563370039476418D0*Z(15)+(-0.05
-++     &581757739455641D0*Z(14))+(-0.07777893205900685D0*Z(13))+0.23117338
-++     &45834199D0*Z(12)+(-0.06031581134427592D0*Z(11))+(-0.14805474755869
-++     &52D0*Z(10))+(-0.3364014128402243D0*Z(9))+0.9364014128402244D0*Z(8)
-++     &+(-0.3269452524413048D0*Z(7))+(-0.1396841886557241D0*Z(6))+(-0.056
-++     &1733845834199D0*Z(5))+0.1777789320590069D0*Z(4)+(-0.04418242260544
-++     &359D0*Z(3))+(-0.02756337003947642D0*Z(2))+0.07361313110326199D0*Z(
-++     &1)
-++      W(9)=0.07361313110326199D0*Z(16)+(-0.02756337003947642D0*Z(15))+(-
-++     &0.04418242260544359D0*Z(14))+0.1777789320590069D0*Z(13)+(-0.056173
-++     &3845834199D0*Z(12))+(-0.1396841886557241D0*Z(11))+(-0.326945252441
-++     &3048D0*Z(10))+0.9364014128402244D0*Z(9)+(-0.3364014128402243D0*Z(8
-++     &))+(-0.1480547475586952D0*Z(7))+(-0.06031581134427592D0*Z(6))+0.23
-++     &11733845834199D0*Z(5)+(-0.07777893205900685D0*Z(4))+(-0.0558175773
-++     &9455641D0*Z(3))+0.002563370039476418D0*Z(2)+0.126386868896738D0*Z(
-++     &1)
-++      W(10)=0.03160990266745513D0*Z(16)+(-0.02065879269286707D0*Z(15))+0
-++     &.2057504515015423D0*Z(14)+(-0.1006185171570586D0*Z(13))+(-0.136246
-++     &3839920727D0*Z(12))+(-0.3199955249404657D0*Z(11))+0.94427911585609
-++     &48D0*Z(10)+(-0.3363262957694705D0*Z(9))+(-0.1559813965382218D0*Z(8
-++     &))+(-0.06735603893301795D0*Z(7))+0.2276878326327734D0*Z(6)+(-0.032
-++     &98438523869648D0*Z(5))+(-0.083996867458326D0*Z(4))+(-0.02113506688
-++     &615768D0*Z(3))+0.06681263884671322D0*Z(2)+0.06069778964023718D0*Z(
-++     &1)
-++      W(11)=0.04254083491825025D0*Z(16)+0.2311852964327382D0*Z(15)+(-0.0
-++     &7037620467004427D0*Z(14))+(-0.1846882042225383D0*Z(13))+(-0.315830
-++     &9975786731D0*Z(12))+0.952576555482747D0*Z(11)+(-0.328001910890377D
-++     &0*Z(10))+(-0.1589391311991561D0*Z(9))+(-0.07375317649315155D0*Z(8)
-++     &)+0.2229538339673001D0*Z(7)+(-0.03526886317505474D0*Z(6))+(-0.0493
-++     &1323319055762D0*Z(5))+(-0.04319641116207706D0*Z(4))+0.048260820054
-++     &65965D0*Z(3)+0.01328585741341559D0*Z(2)+0.04015147277405744D0*Z(1)
-++      W(12)=0.3198209177068516D0*Z(16)+(-0.03423495461011043D0*Z(15))+(-
-++     &0.1417185427288274D0*Z(14))+(-0.3852396953763045D0*Z(13))+0.959162
-++     &3347824002D0*Z(12)+(-0.315042193418466D0*Z(11))+(-0.14739952092889
-++     &45D0*Z(10))+(-0.08249492560213524D0*Z(9))+0.2171103102175198D0*Z(8
-++     &)+(-0.03769663291725935D0*Z(7))+(-0.05034242196614937D0*Z(6))+(-0.
-++     &01445079632086177D0*Z(5))+0.02947046460707379D0*Z(4)+(-0.002512226
-++     &501941856D0*Z(3))+(-0.001822737697581869D0*Z(2))+0.045563697677763
-++     &75D0*Z(1)
-++      W(13)=0.09089205517109111D0*Z(16)+(-0.09033531980693314D0*Z(15))+(
-++     &-0.3241503380268184D0*Z(14))+0.8600427128450191D0*Z(13)+(-0.305169
-++     &742604165D0*Z(12))+(-0.1280829963720053D0*Z(11))+(-0.0663087451453
-++     &5952D0*Z(10))+0.2012230497530726D0*Z(9)+(-0.04353074206076491D0*Z(
-++     &8))+(-0.05051817793156355D0*Z(7))+(-0.014224695935687D0*Z(6))+0.05
-++     &468897337339577D0*Z(5)+(-0.01965809746040371D0*Z(4))+(-0.016234277
-++     &35779699D0*Z(3))+0.005239165960779299D0*Z(2)+0.05141563713660119D0
-++     &*Z(1)
-++      W(14)=(-0.02986582812574917D0*Z(16))+(-0.2995429545781457D0*Z(15))
-++     &+0.8892996132269974D0*Z(14)+(-0.3523683853026259D0*Z(13))+(-0.1236
-++     &679206156403D0*Z(12))+(-0.05760560341383113D0*Z(11))+0.20910979278
-++     &87612D0*Z(10)+(-0.04901428822579872D0*Z(9))+(-0.05483186562035512D
-++     &0*Z(8))+(-0.01632133125029967D0*Z(7))+0.05375944956767728D0*Z(6)+0
-++     &.002033305231024948D0*Z(5)+(-0.03032392238968179D0*Z(4))+(-0.00660
-++     &7305534689702D0*Z(3))+0.02021603150122265D0*Z(2)+0.033711981971903
-++     &02D0*Z(1)
-++      W(15)=(-0.2419652703415429D0*Z(16))+0.9128222941872173D0*Z(15)+(-0
-++     &.3244016605667343D0*Z(14))+(-0.1688977368984641D0*Z(13))+(-0.05325
-++     &555586632358D0*Z(12))+0.2176561076571465D0*Z(11)+(-0.0415311995556
-++     &9051D0*Z(10))+(-0.06095390688679697D0*Z(9))+(-0.01981532388243379D
-++     &0*Z(8))+0.05258889186338282D0*Z(7)+0.00157466157362272D0*Z(6)+(-0.
-++     &0135713672105995D0*Z(5))+(-0.01764072463999744D0*Z(4))+0.010940122
-++     &10519586D0*Z(3)+0.008812321197398072D0*Z(2)+0.0227345011107737D0*Z
-++     &(1)
-++      W(16)=1.019463911841327D0*Z(16)+(-0.2803531651057233D0*Z(15))+(-0.
-++     &1165300508238904D0*Z(14))+(-0.1385343580686922D0*Z(13))+0.22647669
-++     &47290192D0*Z(12)+(-0.02434652144032987D0*Z(11))+(-0.04723268012114
-++     &625D0*Z(10))+(-0.03586220812223305D0*Z(9))+0.04932374658377151D0*Z
-++     &(8)+0.00372306473653087D0*Z(7)+(-0.01219194009813166D0*Z(6))+(-0.0
-++     &07005540882865317D0*Z(5))+0.002957434991769087D0*Z(4)+0.0021069739
-++     &00813502D0*Z(3)+0.001747395874954051D0*Z(2)+0.01707454969713436D0*
-++     &Z(1)
-++      RETURN
-++      END
-++\end{verbatim}
+++f02fjf, for example:
+++
+++\tab{5}SUBROUTINE IMAGE(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)\br
+++\tab{5}DOUBLE PRECISION Z(N),W(N),IWORK(LRWORK),RWORK(LRWORK)\br
+++\tab{5}INTEGER N,LIWORK,IFLAG,LRWORK\br
+++\tab{5}W(1)=0.01707454969713436D0*Z(16)+0.001747395874954051D0*Z(15)+0.00\br
+++\tab{4}&2106973900813502D0*Z(14)+0.002957434991769087D0*Z(13)+(-0.00700554\br
+++\tab{4}&0882865317D0*Z(12))+(-0.01219194009813166D0*Z(11))+0.0037230647365\br
+++\tab{4}&3087D0*Z(10)+0.04932374658377151D0*Z(9)+(-0.03586220812223305D0*Z(\br
+++\tab{4}&8))+(-0.04723268012114625D0*Z(7))+(-0.02434652144032987D0*Z(6))+0.\br
+++\tab{4}&2264766947290192D0*Z(5)+(-0.1385343580686922D0*Z(4))+(-0.116530050\br
+++\tab{4}&8238904D0*Z(3))+(-0.2803531651057233D0*Z(2))+1.019463911841327D0*Z\br
+++\tab{4}&(1)\br
+++\tab{5}W(2)=0.0227345011107737D0*Z(16)+0.008812321197398072D0*Z(15)+0.010\br
+++\tab{4}&94012210519586D0*Z(14)+(-0.01764072463999744D0*Z(13))+(-0.01357136\br
+++\tab{4}&72105995D0*Z(12))+0.00157466157362272D0*Z(11)+0.05258889186338282D\br
+++\tab{4}&0*Z(10)+(-0.01981532388243379D0*Z(9))+(-0.06095390688679697D0*Z(8)\br
+++\tab{4}&)+(-0.04153119955569051D0*Z(7))+0.2176561076571465D0*Z(6)+(-0.0532\br
+++\tab{4}&5555586632358D0*Z(5))+(-0.1688977368984641D0*Z(4))+(-0.32440166056\br
+++\tab{4}&67343D0*Z(3))+0.9128222941872173D0*Z(2)+(-0.2419652703415429D0*Z(1\br
+++\tab{4}&))\br
+++\tab{5}W(3)=0.03371198197190302D0*Z(16)+0.02021603150122265D0*Z(15)+(-0.0\br
+++\tab{4}&06607305534689702D0*Z(14))+(-0.03032392238968179D0*Z(13))+0.002033\br
+++\tab{4}&305231024948D0*Z(12)+0.05375944956767728D0*Z(11)+(-0.0163213312502\br
+++\tab{4}&9967D0*Z(10))+(-0.05483186562035512D0*Z(9))+(-0.04901428822579872D\br
+++\tab{4}&0*Z(8))+0.2091097927887612D0*Z(7)+(-0.05760560341383113D0*Z(6))+(-\br
+++\tab{4}&0.1236679206156403D0*Z(5))+(-0.3523683853026259D0*Z(4))+0.88929961\br
+++\tab{4}&32269974D0*Z(3)+(-0.2995429545781457D0*Z(2))+(-0.02986582812574917\br
+++\tab{4}&D0*Z(1))\br
+++\tab{5}W(4)=0.05141563713660119D0*Z(16)+0.005239165960779299D0*Z(15)+(-0.\br
+++\tab{4}&01623427735779699D0*Z(14))+(-0.01965809746040371D0*Z(13))+0.054688\br
+++\tab{4}&97337339577D0*Z(12)+(-0.014224695935687D0*Z(11))+(-0.0505181779315\br
+++\tab{4}&6355D0*Z(10))+(-0.04353074206076491D0*Z(9))+0.2012230497530726D0*Z\br
+++\tab{4}&(8)+(-0.06630874514535952D0*Z(7))+(-0.1280829963720053D0*Z(6))+(-0\br
+++\tab{4}&.305169742604165D0*Z(5))+0.8600427128450191D0*Z(4)+(-0.32415033802\br
+++\tab{4}&68184D0*Z(3))+(-0.09033531980693314D0*Z(2))+0.09089205517109111D0*\br
+++\tab{4}&Z(1)\br
+++\tab{5}W(5)=0.04556369767776375D0*Z(16)+(-0.001822737697581869D0*Z(15))+(\br
+++\tab{4}&-0.002512226501941856D0*Z(14))+0.02947046460707379D0*Z(13)+(-0.014\br
+++\tab{4}&45079632086177D0*Z(12))+(-0.05034242196614937D0*Z(11))+(-0.0376966\br
+++\tab{4}&3291725935D0*Z(10))+0.2171103102175198D0*Z(9)+(-0.0824949256021352\br
+++\tab{4}&4D0*Z(8))+(-0.1473995209288945D0*Z(7))+(-0.315042193418466D0*Z(6))\br
+++\tab{4}&+0.9591623347824002D0*Z(5)+(-0.3852396953763045D0*Z(4))+(-0.141718\br
+++\tab{4}&5427288274D0*Z(3))+(-0.03423495461011043D0*Z(2))+0.319820917706851\br
+++\tab{4}&6D0*Z(1)\br
+++\tab{5}W(6)=0.04015147277405744D0*Z(16)+0.01328585741341559D0*Z(15)+0.048\br
+++\tab{4}&26082005465965D0*Z(14)+(-0.04319641116207706D0*Z(13))+(-0.04931323\br
+++\tab{4}&319055762D0*Z(12))+(-0.03526886317505474D0*Z(11))+0.22295383396730\br
+++\tab{4}&01D0*Z(10)+(-0.07375317649315155D0*Z(9))+(-0.1589391311991561D0*Z(\br
+++\tab{4}&8))+(-0.328001910890377D0*Z(7))+0.952576555482747D0*Z(6)+(-0.31583\br
+++\tab{4}&09975786731D0*Z(5))+(-0.1846882042225383D0*Z(4))+(-0.0703762046700\br
+++\tab{4}&4427D0*Z(3))+0.2311852964327382D0*Z(2)+0.04254083491825025D0*Z(1)\br
+++\tab{5}W(7)=0.06069778964023718D0*Z(16)+0.06681263884671322D0*Z(15)+(-0.0\br
+++\tab{4}&2113506688615768D0*Z(14))+(-0.083996867458326D0*Z(13))+(-0.0329843\br
+++\tab{4}&8523869648D0*Z(12))+0.2276878326327734D0*Z(11)+(-0.067356038933017\br
+++\tab{4}&95D0*Z(10))+(-0.1559813965382218D0*Z(9))+(-0.3363262957694705D0*Z(\br
+++\tab{4}&8))+0.9442791158560948D0*Z(7)+(-0.3199955249404657D0*Z(6))+(-0.136\br
+++\tab{4}&2463839920727D0*Z(5))+(-0.1006185171570586D0*Z(4))+0.2057504515015\br
+++\tab{4}&423D0*Z(3)+(-0.02065879269286707D0*Z(2))+0.03160990266745513D0*Z(1\br
+++\tab{4}&)\br
+++\tab{5}W(8)=0.126386868896738D0*Z(16)+0.002563370039476418D0*Z(15)+(-0.05\br
+++\tab{4}&581757739455641D0*Z(14))+(-0.07777893205900685D0*Z(13))+0.23117338\br
+++\tab{4}&45834199D0*Z(12)+(-0.06031581134427592D0*Z(11))+(-0.14805474755869\br
+++\tab{4}&52D0*Z(10))+(-0.3364014128402243D0*Z(9))+0.9364014128402244D0*Z(8)\br
+++\tab{4}&+(-0.3269452524413048D0*Z(7))+(-0.1396841886557241D0*Z(6))+(-0.056\br
+++\tab{4}&1733845834199D0*Z(5))+0.1777789320590069D0*Z(4)+(-0.04418242260544\br
+++\tab{4}&359D0*Z(3))+(-0.02756337003947642D0*Z(2))+0.07361313110326199D0*Z(\br
+++\tab{4}&1)\br
+++\tab{5}W(9)=0.07361313110326199D0*Z(16)+(-0.02756337003947642D0*Z(15))+(-\br
+++\tab{4}&0.04418242260544359D0*Z(14))+0.1777789320590069D0*Z(13)+(-0.056173\br
+++\tab{4}&3845834199D0*Z(12))+(-0.1396841886557241D0*Z(11))+(-0.326945252441\br
+++\tab{4}&3048D0*Z(10))+0.9364014128402244D0*Z(9)+(-0.3364014128402243D0*Z(8\br
+++\tab{4}&))+(-0.1480547475586952D0*Z(7))+(-0.06031581134427592D0*Z(6))+0.23\br
+++\tab{4}&11733845834199D0*Z(5)+(-0.07777893205900685D0*Z(4))+(-0.0558175773\br
+++\tab{4}&9455641D0*Z(3))+0.002563370039476418D0*Z(2)+0.126386868896738D0*Z(\br
+++\tab{4}&1)\br
+++\tab{5}W(10)=0.03160990266745513D0*Z(16)+(-0.02065879269286707D0*Z(15))+0\br
+++\tab{4}&.2057504515015423D0*Z(14)+(-0.1006185171570586D0*Z(13))+(-0.136246\br
+++\tab{4}&3839920727D0*Z(12))+(-0.3199955249404657D0*Z(11))+0.94427911585609\br
+++\tab{4}&48D0*Z(10)+(-0.3363262957694705D0*Z(9))+(-0.1559813965382218D0*Z(8\br
+++\tab{4}&))+(-0.06735603893301795D0*Z(7))+0.2276878326327734D0*Z(6)+(-0.032\br
+++\tab{4}&98438523869648D0*Z(5))+(-0.083996867458326D0*Z(4))+(-0.02113506688\br
+++\tab{4}&615768D0*Z(3))+0.06681263884671322D0*Z(2)+0.06069778964023718D0*Z(\br
+++\tab{4}&1)\br
+++\tab{5}W(11)=0.04254083491825025D0*Z(16)+0.2311852964327382D0*Z(15)+(-0.0\br
+++\tab{4}&7037620467004427D0*Z(14))+(-0.1846882042225383D0*Z(13))+(-0.315830\br
+++\tab{4}&9975786731D0*Z(12))+0.952576555482747D0*Z(11)+(-0.328001910890377D\br
+++\tab{4}&0*Z(10))+(-0.1589391311991561D0*Z(9))+(-0.07375317649315155D0*Z(8)\br
+++\tab{4}&)+0.2229538339673001D0*Z(7)+(-0.03526886317505474D0*Z(6))+(-0.0493\br
+++\tab{4}&1323319055762D0*Z(5))+(-0.04319641116207706D0*Z(4))+0.048260820054\br
+++\tab{4}&65965D0*Z(3)+0.01328585741341559D0*Z(2)+0.04015147277405744D0*Z(1)\br
+++\tab{5}W(12)=0.3198209177068516D0*Z(16)+(-0.03423495461011043D0*Z(15))+(-\br
+++\tab{4}&0.1417185427288274D0*Z(14))+(-0.3852396953763045D0*Z(13))+0.959162\br
+++\tab{4}&3347824002D0*Z(12)+(-0.315042193418466D0*Z(11))+(-0.14739952092889\br
+++\tab{4}&45D0*Z(10))+(-0.08249492560213524D0*Z(9))+0.2171103102175198D0*Z(8\br
+++\tab{4}&)+(-0.03769663291725935D0*Z(7))+(-0.05034242196614937D0*Z(6))+(-0.\br
+++\tab{4}&01445079632086177D0*Z(5))+0.02947046460707379D0*Z(4)+(-0.002512226\br
+++\tab{4}&501941856D0*Z(3))+(-0.001822737697581869D0*Z(2))+0.045563697677763\br
+++\tab{4}&75D0*Z(1)\br
+++\tab{5}W(13)=0.09089205517109111D0*Z(16)+(-0.09033531980693314D0*Z(15))+(\br
+++\tab{4}&-0.3241503380268184D0*Z(14))+0.8600427128450191D0*Z(13)+(-0.305169\br
+++\tab{4}&742604165D0*Z(12))+(-0.1280829963720053D0*Z(11))+(-0.0663087451453\br
+++\tab{4}&5952D0*Z(10))+0.2012230497530726D0*Z(9)+(-0.04353074206076491D0*Z(\br
+++\tab{4}&8))+(-0.05051817793156355D0*Z(7))+(-0.014224695935687D0*Z(6))+0.05\br
+++\tab{4}&468897337339577D0*Z(5)+(-0.01965809746040371D0*Z(4))+(-0.016234277\br
+++\tab{4}&35779699D0*Z(3))+0.005239165960779299D0*Z(2)+0.05141563713660119D0\br
+++\tab{4}&*Z(1)\br
+++\tab{5}W(14)=(-0.02986582812574917D0*Z(16))+(-0.2995429545781457D0*Z(15))\br
+++\tab{4}&+0.8892996132269974D0*Z(14)+(-0.3523683853026259D0*Z(13))+(-0.1236\br
+++\tab{4}&679206156403D0*Z(12))+(-0.05760560341383113D0*Z(11))+0.20910979278\br
+++\tab{4}&87612D0*Z(10)+(-0.04901428822579872D0*Z(9))+(-0.05483186562035512D\br
+++\tab{4}&0*Z(8))+(-0.01632133125029967D0*Z(7))+0.05375944956767728D0*Z(6)+0\br
+++\tab{4}&.002033305231024948D0*Z(5)+(-0.03032392238968179D0*Z(4))+(-0.00660\br
+++\tab{4}&7305534689702D0*Z(3))+0.02021603150122265D0*Z(2)+0.033711981971903\br
+++\tab{4}&02D0*Z(1)\br
+++\tab{5}W(15)=(-0.2419652703415429D0*Z(16))+0.9128222941872173D0*Z(15)+(-0\br
+++\tab{4}&.3244016605667343D0*Z(14))+(-0.1688977368984641D0*Z(13))+(-0.05325\br
+++\tab{4}&555586632358D0*Z(12))+0.2176561076571465D0*Z(11)+(-0.0415311995556\br
+++\tab{4}&9051D0*Z(10))+(-0.06095390688679697D0*Z(9))+(-0.01981532388243379D\br
+++\tab{4}&0*Z(8))+0.05258889186338282D0*Z(7)+0.00157466157362272D0*Z(6)+(-0.\br
+++\tab{4}&0135713672105995D0*Z(5))+(-0.01764072463999744D0*Z(4))+0.010940122\br
+++\tab{4}&10519586D0*Z(3)+0.008812321197398072D0*Z(2)+0.0227345011107737D0*Z\br
+++\tab{4}&(1)\br
+++\tab{5}W(16)=1.019463911841327D0*Z(16)+(-0.2803531651057233D0*Z(15))+(-0.\br
+++\tab{4}&1165300508238904D0*Z(14))+(-0.1385343580686922D0*Z(13))+0.22647669\br
+++\tab{4}&47290192D0*Z(12)+(-0.02434652144032987D0*Z(11))+(-0.04723268012114\br
+++\tab{4}&625D0*Z(10))+(-0.03586220812223305D0*Z(9))+0.04932374658377151D0*Z\br
+++\tab{4}&(8)+0.00372306473653087D0*Z(7)+(-0.01219194009813166D0*Z(6))+(-0.0\br
+++\tab{4}&07005540882865317D0*Z(5))+0.002957434991769087D0*Z(4)+0.0021069739\br
+++\tab{4}&00813502D0*Z(3)+0.001747395874954051D0*Z(2)+0.01707454969713436D0*\br
+++\tab{4}&Z(1)\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
 
 Asp28(name): Exports == Implementation where
   name : Symbol
@@ -4037,15 +4027,14 @@ Asp28(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp29} produces Fortran for Type 29 ASPs, needed for NAG routine
-++\axiomOpFrom{f02fjf}{f02Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE MONIT(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)
-++      DOUBLE PRECISION D(K),F(K)
-++      INTEGER K,NEXTIT,NEVALS,NVECS,ISTATE
-++      CALL F02FJZ(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)
-++      RETURN
-++      END
-++\end{verbatim}
+++f02fjf, for example:
+++
+++\tab{5}SUBROUTINE MONIT(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)\br
+++\tab{5}DOUBLE PRECISION D(K),F(K)\br
+++\tab{5}INTEGER K,NEXTIT,NEVALS,NVECS,ISTATE\br
+++\tab{5}CALL F02FJZ(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
 
 Asp29(name): Exports == Implementation where
   name : Symbol
@@ -4125,46 +4114,45 @@ Asp29(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp30} produces Fortran for Type 30 ASPs, needed for NAG routine
-++\axiomOpFrom{f04qaf}{f04Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE APROD(MODE,M,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)
-++      DOUBLE PRECISION X(N),Y(M),RWORK(LRWORK)
-++      INTEGER M,N,LIWORK,IFAIL,LRWORK,IWORK(LIWORK),MODE
-++      DOUBLE PRECISION A(5,5)
-++      EXTERNAL F06PAF
-++      A(1,1)=1.0D0
-++      A(1,2)=0.0D0
-++      A(1,3)=0.0D0
-++      A(1,4)=-1.0D0
-++      A(1,5)=0.0D0
-++      A(2,1)=0.0D0
-++      A(2,2)=1.0D0
-++      A(2,3)=0.0D0
-++      A(2,4)=0.0D0
-++      A(2,5)=-1.0D0
-++      A(3,1)=0.0D0
-++      A(3,2)=0.0D0
-++      A(3,3)=1.0D0
-++      A(3,4)=-1.0D0
-++      A(3,5)=0.0D0
-++      A(4,1)=-1.0D0
-++      A(4,2)=0.0D0
-++      A(4,3)=-1.0D0
-++      A(4,4)=4.0D0
-++      A(4,5)=-1.0D0
-++      A(5,1)=0.0D0
-++      A(5,2)=-1.0D0
-++      A(5,3)=0.0D0
-++      A(5,4)=-1.0D0
-++      A(5,5)=4.0D0
-++      IF(MODE.EQ.1)THEN
-++        CALL F06PAF('N',M,N,1.0D0,A,M,X,1,1.0D0,Y,1)
-++      ELSEIF(MODE.EQ.2)THEN
-++        CALL F06PAF('T',M,N,1.0D0,A,M,Y,1,1.0D0,X,1)
-++      ENDIF
-++      RETURN
-++      END
-++\end{verbatim}
+++f04qaf, for example:
+++
+++\tab{5}SUBROUTINE APROD(MODE,M,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)\br
+++\tab{5}DOUBLE PRECISION X(N),Y(M),RWORK(LRWORK)\br
+++\tab{5}INTEGER M,N,LIWORK,IFAIL,LRWORK,IWORK(LIWORK),MODE\br
+++\tab{5}DOUBLE PRECISION A(5,5)\br
+++\tab{5}EXTERNAL F06PAF\br
+++\tab{5}A(1,1)=1.0D0\br
+++\tab{5}A(1,2)=0.0D0\br
+++\tab{5}A(1,3)=0.0D0\br
+++\tab{5}A(1,4)=-1.0D0\br
+++\tab{5}A(1,5)=0.0D0\br
+++\tab{5}A(2,1)=0.0D0\br
+++\tab{5}A(2,2)=1.0D0\br
+++\tab{5}A(2,3)=0.0D0\br
+++\tab{5}A(2,4)=0.0D0\br
+++\tab{5}A(2,5)=-1.0D0\br
+++\tab{5}A(3,1)=0.0D0\br
+++\tab{5}A(3,2)=0.0D0\br
+++\tab{5}A(3,3)=1.0D0\br
+++\tab{5}A(3,4)=-1.0D0\br
+++\tab{5}A(3,5)=0.0D0\br
+++\tab{5}A(4,1)=-1.0D0\br
+++\tab{5}A(4,2)=0.0D0\br
+++\tab{5}A(4,3)=-1.0D0\br
+++\tab{5}A(4,4)=4.0D0\br
+++\tab{5}A(4,5)=-1.0D0\br
+++\tab{5}A(5,1)=0.0D0\br
+++\tab{5}A(5,2)=-1.0D0\br
+++\tab{5}A(5,3)=0.0D0\br
+++\tab{5}A(5,4)=-1.0D0\br
+++\tab{5}A(5,5)=4.0D0\br
+++\tab{5}IF(MODE.EQ.1)THEN\br
+++\tab{7}CALL F06PAF('N',M,N,1.0D0,A,M,X,1,1.0D0,Y,1)\br
+++\tab{5}ELSEIF(MODE.EQ.2)THEN\br
+++\tab{7}CALL F06PAF('T',M,N,1.0D0,A,M,Y,1,1.0D0,X,1)\br
+++\tab{5}ENDIF\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp30(name): Exports == Implementation where
   name : Symbol
@@ -4270,23 +4258,22 @@ Asp30(name): Exports == Implementation where
 ++ Related Constructors: FortranMatrixFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp31} produces Fortran for Type 31 ASPs, needed for NAG routine 
-++\axiomOpFrom{d02ejf}{d02Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE PEDERV(X,Y,PW)
-++      DOUBLE PRECISION X,Y(*)
-++      DOUBLE PRECISION PW(3,3)
-++      PW(1,1)=-0.03999999999999999D0
-++      PW(1,2)=10000.0D0*Y(3)
-++      PW(1,3)=10000.0D0*Y(2)
-++      PW(2,1)=0.03999999999999999D0
-++      PW(2,2)=(-10000.0D0*Y(3))+(-60000000.0D0*Y(2))
-++      PW(2,3)=-10000.0D0*Y(2)
-++      PW(3,1)=0.0D0
-++      PW(3,2)=60000000.0D0*Y(2)
-++      PW(3,3)=0.0D0
-++      RETURN
-++      END
-++\end{verbatim}
+++d02ejf, for example:
+++
+++\tab{5}SUBROUTINE PEDERV(X,Y,PW)\br
+++\tab{5}DOUBLE PRECISION X,Y(*)\br
+++\tab{5}DOUBLE PRECISION PW(3,3)\br
+++\tab{5}PW(1,1)=-0.03999999999999999D0\br
+++\tab{5}PW(1,2)=10000.0D0*Y(3)\br
+++\tab{5}PW(1,3)=10000.0D0*Y(2)\br
+++\tab{5}PW(2,1)=0.03999999999999999D0\br
+++\tab{5}PW(2,2)=(-10000.0D0*Y(3))+(-60000000.0D0*Y(2))\br
+++\tab{5}PW(2,3)=-10000.0D0*Y(2)\br
+++\tab{5}PW(3,1)=0.0D0\br
+++\tab{5}PW(3,2)=60000000.0D0*Y(2)\br
+++\tab{5}PW(3,3)=0.0D0\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp31(name): Exports == Implementation where
   name : Symbol
@@ -4446,14 +4433,13 @@ Asp31(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory.
 ++ Description:
 ++\spadtype{Asp33} produces Fortran for Type 33 ASPs, needed for NAG routine 
-++\axiomOpFrom{d02kef}{d02Package}.  The code is a dummy ASP:
-++\begin{verbatim}
-++      SUBROUTINE REPORT(X,V,JINT)
-++      DOUBLE PRECISION V(3),X
-++      INTEGER JINT
-++      RETURN
-++      END
-++\end{verbatim}
+++d02kef.  The code is a dummy ASP:
+++
+++\tab{5}SUBROUTINE REPORT(X,V,JINT)\br
+++\tab{5}DOUBLE PRECISION V(3),X\br
+++\tab{5}INTEGER JINT\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp33(name): Exports == Implementation where
   name : Symbol
@@ -4514,27 +4500,26 @@ Asp33(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp34} produces Fortran for Type 34 ASPs, needed for NAG routine 
-++\axiomOpFrom{f04mbf}{f04Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE MSOLVE(IFLAG,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)
-++      DOUBLE PRECISION RWORK(LRWORK),X(N),Y(N)
-++      INTEGER I,J,N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)
-++      DOUBLE PRECISION W1(3),W2(3),MS(3,3)
-++      IFLAG=-1
-++      MS(1,1)=2.0D0
-++      MS(1,2)=1.0D0
-++      MS(1,3)=0.0D0
-++      MS(2,1)=1.0D0
-++      MS(2,2)=2.0D0
-++      MS(2,3)=1.0D0
-++      MS(3,1)=0.0D0
-++      MS(3,2)=1.0D0
-++      MS(3,3)=2.0D0
-++      CALL F04ASF(MS,N,X,N,Y,W1,W2,IFLAG)
-++      IFLAG=-IFLAG
-++      RETURN
-++      END
-++\end{verbatim}
+++f04mbf, for example:
+++
+++\tab{5}SUBROUTINE MSOLVE(IFLAG,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)\br
+++\tab{5}DOUBLE PRECISION RWORK(LRWORK),X(N),Y(N)\br
+++\tab{5}INTEGER I,J,N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)\br
+++\tab{5}DOUBLE PRECISION W1(3),W2(3),MS(3,3)\br
+++\tab{5}IFLAG=-1\br
+++\tab{5}MS(1,1)=2.0D0\br
+++\tab{5}MS(1,2)=1.0D0\br
+++\tab{5}MS(1,3)=0.0D0\br
+++\tab{5}MS(2,1)=1.0D0\br
+++\tab{5}MS(2,2)=2.0D0\br
+++\tab{5}MS(2,3)=1.0D0\br
+++\tab{5}MS(3,1)=0.0D0\br
+++\tab{5}MS(3,2)=1.0D0\br
+++\tab{5}MS(3,3)=2.0D0\br
+++\tab{5}CALL F04ASF(MS,N,X,N,Y,W1,W2,IFLAG)\br
+++\tab{5}IFLAG=-IFLAG\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp34(name): Exports == Implementation where
   name : Symbol
@@ -4631,28 +4616,27 @@ Asp34(name): Exports == Implementation where
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp35} produces Fortran for Type 35 ASPs, needed for NAG routines 
-++\axiomOpFrom{c05pbf}{c05Package}, \axiomOpFrom{c05pcf}{c05Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE FCN(N,X,FVEC,FJAC,LDFJAC,IFLAG)
-++      DOUBLE PRECISION X(N),FVEC(N),FJAC(LDFJAC,N)
-++      INTEGER LDFJAC,N,IFLAG
-++      IF(IFLAG.EQ.1)THEN
-++        FVEC(1)=(-1.0D0*X(2))+X(1)
-++        FVEC(2)=(-1.0D0*X(3))+2.0D0*X(2)
-++        FVEC(3)=3.0D0*X(3)
-++      ELSEIF(IFLAG.EQ.2)THEN
-++        FJAC(1,1)=1.0D0
-++        FJAC(1,2)=-1.0D0
-++        FJAC(1,3)=0.0D0
-++        FJAC(2,1)=0.0D0
-++        FJAC(2,2)=2.0D0
-++        FJAC(2,3)=-1.0D0
-++        FJAC(3,1)=0.0D0
-++        FJAC(3,2)=0.0D0
-++        FJAC(3,3)=3.0D0
-++      ENDIF
-++      END
-++\end{verbatim}
+++c05pbf, c05pcf, for example:
+++
+++\tab{5}SUBROUTINE FCN(N,X,FVEC,FJAC,LDFJAC,IFLAG)\br
+++\tab{5}DOUBLE PRECISION X(N),FVEC(N),FJAC(LDFJAC,N)\br
+++\tab{5}INTEGER LDFJAC,N,IFLAG\br
+++\tab{5}IF(IFLAG.EQ.1)THEN\br
+++\tab{7}FVEC(1)=(-1.0D0*X(2))+X(1)\br
+++\tab{7}FVEC(2)=(-1.0D0*X(3))+2.0D0*X(2)\br
+++\tab{7}FVEC(3)=3.0D0*X(3)\br
+++\tab{5}ELSEIF(IFLAG.EQ.2)THEN\br
+++\tab{7}FJAC(1,1)=1.0D0\br
+++\tab{7}FJAC(1,2)=-1.0D0\br
+++\tab{7}FJAC(1,3)=0.0D0\br
+++\tab{7}FJAC(2,1)=0.0D0\br
+++\tab{7}FJAC(2,2)=2.0D0\br
+++\tab{7}FJAC(2,3)=-1.0D0\br
+++\tab{7}FJAC(3,1)=0.0D0\br
+++\tab{7}FJAC(3,2)=0.0D0\br
+++\tab{7}FJAC(3,3)=3.0D0\br
+++\tab{5}ENDIF\br
+++\tab{5}END
 
 Asp35(name): Exports == Implementation where
   name : Symbol
@@ -4821,15 +4805,14 @@ Asp35(name): Exports == Implementation where
 ++ Description:
 ++\spadtype{Asp4} produces Fortran for Type 4 ASPs, which take an expression
 ++in X(1) .. X(NDIM) and produce a real function of the form:
-++\begin{verbatim}
-++      DOUBLE PRECISION FUNCTION FUNCTN(NDIM,X)
-++      DOUBLE PRECISION X(NDIM)
-++      INTEGER NDIM
-++      FUNCTN=(4.0D0*X(1)*X(3)**2*DEXP(2.0D0*X(1)*X(3)))/(X(4)**2+(2.0D0*
-++     &X(2)+2.0D0)*X(4)+X(2)**2+2.0D0*X(2)+1.0D0)
-++      RETURN
-++      END
-++\end{verbatim}
+++
+++\tab{5}DOUBLE PRECISION FUNCTION FUNCTN(NDIM,X)\br
+++\tab{5}DOUBLE PRECISION X(NDIM)\br
+++\tab{5}INTEGER NDIM\br
+++\tab{5}FUNCTN=(4.0D0*X(1)*X(3)**2*DEXP(2.0D0*X(1)*X(3)))/(X(4)**2+(2.0D0*\br
+++\tab{4}&X(2)+2.0D0)*X(4)+X(2)**2+2.0D0*X(2)+1.0D0)\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp4(name): Exports == Implementation where
   name : Symbol
@@ -4947,43 +4930,40 @@ Asp4(name): Exports == Implementation where
 ++ Related Constructors: FortranFunctionCategory, FortranProgramCategory.
 ++ Description:
 ++\spadtype{Asp41} produces Fortran for Type 41 ASPs, needed for NAG
-++routines \axiomOpFrom{d02raf}{d02Package} and 
-++\axiomOpFrom{d02saf}{d02Package}
-++in particular.  These ASPs are in fact 
+++routines d02raf and d02saf in particular.  These ASPs are in fact 
 ++three Fortran routines which return a vector of functions, and their
 ++derivatives wrt Y(i) and also a continuation parameter EPS, for example:
-++\begin{verbatim}
-++      SUBROUTINE FCN(X,EPS,Y,F,N)
-++      DOUBLE PRECISION EPS,F(N),X,Y(N)
-++      INTEGER N
-++      F(1)=Y(2)
-++      F(2)=Y(3)
-++      F(3)=(-1.0D0*Y(1)*Y(3))+2.0D0*EPS*Y(2)**2+(-2.0D0*EPS)
-++      RETURN
-++      END
-++      SUBROUTINE JACOBF(X,EPS,Y,F,N)
-++      DOUBLE PRECISION EPS,F(N,N),X,Y(N)
-++      INTEGER N
-++      F(1,1)=0.0D0
-++      F(1,2)=1.0D0
-++      F(1,3)=0.0D0
-++      F(2,1)=0.0D0
-++      F(2,2)=0.0D0
-++      F(2,3)=1.0D0
-++      F(3,1)=-1.0D0*Y(3)
-++      F(3,2)=4.0D0*EPS*Y(2)
-++      F(3,3)=-1.0D0*Y(1)
-++      RETURN
-++      END
-++      SUBROUTINE JACEPS(X,EPS,Y,F,N)
-++      DOUBLE PRECISION EPS,F(N),X,Y(N)
-++      INTEGER N
-++      F(1)=0.0D0
-++      F(2)=0.0D0
-++      F(3)=2.0D0*Y(2)**2-2.0D0
-++      RETURN
-++      END
-++\end{verbatim}
+++
+++\tab{5}SUBROUTINE FCN(X,EPS,Y,F,N)\br
+++\tab{5}DOUBLE PRECISION EPS,F(N),X,Y(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}F(1)=Y(2)\br
+++\tab{5}F(2)=Y(3)\br
+++\tab{5}F(3)=(-1.0D0*Y(1)*Y(3))+2.0D0*EPS*Y(2)**2+(-2.0D0*EPS)\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
+++\tab{5}SUBROUTINE JACOBF(X,EPS,Y,F,N)\br
+++\tab{5}DOUBLE PRECISION EPS,F(N,N),X,Y(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}F(1,1)=0.0D0\br
+++\tab{5}F(1,2)=1.0D0\br
+++\tab{5}F(1,3)=0.0D0\br
+++\tab{5}F(2,1)=0.0D0\br
+++\tab{5}F(2,2)=0.0D0\br
+++\tab{5}F(2,3)=1.0D0\br
+++\tab{5}F(3,1)=-1.0D0*Y(3)\br
+++\tab{5}F(3,2)=4.0D0*EPS*Y(2)\br
+++\tab{5}F(3,3)=-1.0D0*Y(1)\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
+++\tab{5}SUBROUTINE JACEPS(X,EPS,Y,F,N)\br
+++\tab{5}DOUBLE PRECISION EPS,F(N),X,Y(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}F(1)=0.0D0\br
+++\tab{5}F(2)=0.0D0\br
+++\tab{5}F(3)=2.0D0*Y(2)**2-2.0D0\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp41(nameOne,nameTwo,nameThree): Exports == Implementation where
   nameOne : Symbol
@@ -5184,51 +5164,50 @@ Asp41(nameOne,nameTwo,nameThree): Exports == Implementation where
 ++ Related Constructors: FortranFunctionCategory, FortranProgramCategory.
 ++ Description:
 ++\spadtype{Asp42} produces Fortran for Type 42 ASPs, needed for NAG
-++routines \axiomOpFrom{d02raf}{d02Package} and \axiomOpFrom{d02saf}{d02Package}
+++routines d02raf and d02saf
 ++in particular.  These ASPs are in fact
 ++three Fortran routines which return a vector of functions, and their
 ++derivatives wrt Y(i) and also a continuation parameter EPS, for example:
-++\begin{verbatim}
-++      SUBROUTINE G(EPS,YA,YB,BC,N)
-++      DOUBLE PRECISION EPS,YA(N),YB(N),BC(N)
-++      INTEGER N
-++      BC(1)=YA(1)
-++      BC(2)=YA(2)
-++      BC(3)=YB(2)-1.0D0
-++      RETURN
-++      END
-++      SUBROUTINE JACOBG(EPS,YA,YB,AJ,BJ,N)
-++      DOUBLE PRECISION EPS,YA(N),AJ(N,N),BJ(N,N),YB(N)
-++      INTEGER N
-++      AJ(1,1)=1.0D0
-++      AJ(1,2)=0.0D0
-++      AJ(1,3)=0.0D0
-++      AJ(2,1)=0.0D0
-++      AJ(2,2)=1.0D0
-++      AJ(2,3)=0.0D0
-++      AJ(3,1)=0.0D0
-++      AJ(3,2)=0.0D0
-++      AJ(3,3)=0.0D0
-++      BJ(1,1)=0.0D0
-++      BJ(1,2)=0.0D0
-++      BJ(1,3)=0.0D0
-++      BJ(2,1)=0.0D0
-++      BJ(2,2)=0.0D0
-++      BJ(2,3)=0.0D0
-++      BJ(3,1)=0.0D0
-++      BJ(3,2)=1.0D0
-++      BJ(3,3)=0.0D0
-++      RETURN
-++      END
-++      SUBROUTINE JACGEP(EPS,YA,YB,BCEP,N)
-++      DOUBLE PRECISION EPS,YA(N),YB(N),BCEP(N)
-++      INTEGER N
-++      BCEP(1)=0.0D0
-++      BCEP(2)=0.0D0
-++      BCEP(3)=0.0D0
-++      RETURN
-++      END
-++\end{verbatim}
+++
+++\tab{5}SUBROUTINE G(EPS,YA,YB,BC,N)\br
+++\tab{5}DOUBLE PRECISION EPS,YA(N),YB(N),BC(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}BC(1)=YA(1)\br
+++\tab{5}BC(2)=YA(2)\br
+++\tab{5}BC(3)=YB(2)-1.0D0\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
+++\tab{5}SUBROUTINE JACOBG(EPS,YA,YB,AJ,BJ,N)\br
+++\tab{5}DOUBLE PRECISION EPS,YA(N),AJ(N,N),BJ(N,N),YB(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}AJ(1,1)=1.0D0\br
+++\tab{5}AJ(1,2)=0.0D0\br
+++\tab{5}AJ(1,3)=0.0D0\br
+++\tab{5}AJ(2,1)=0.0D0\br
+++\tab{5}AJ(2,2)=1.0D0\br
+++\tab{5}AJ(2,3)=0.0D0\br
+++\tab{5}AJ(3,1)=0.0D0\br
+++\tab{5}AJ(3,2)=0.0D0\br
+++\tab{5}AJ(3,3)=0.0D0\br
+++\tab{5}BJ(1,1)=0.0D0\br
+++\tab{5}BJ(1,2)=0.0D0\br
+++\tab{5}BJ(1,3)=0.0D0\br
+++\tab{5}BJ(2,1)=0.0D0\br
+++\tab{5}BJ(2,2)=0.0D0\br
+++\tab{5}BJ(2,3)=0.0D0\br
+++\tab{5}BJ(3,1)=0.0D0\br
+++\tab{5}BJ(3,2)=1.0D0\br
+++\tab{5}BJ(3,3)=0.0D0\br
+++\tab{5}RETURN\br
+++\tab{5}END\br
+++\tab{5}SUBROUTINE JACGEP(EPS,YA,YB,BCEP,N)\br
+++\tab{5}DOUBLE PRECISION EPS,YA(N),YB(N),BCEP(N)\br
+++\tab{5}INTEGER N\br
+++\tab{5}BCEP(1)=0.0D0\br
+++\tab{5}BCEP(2)=0.0D0\br
+++\tab{5}BCEP(3)=0.0D0\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp42(nameOne,nameTwo,nameThree): Exports == Implementation where
   nameOne : Symbol
@@ -5441,25 +5420,24 @@ Asp42(nameOne,nameTwo,nameThree): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp49} produces Fortran for Type 49 ASPs, needed for NAG routines
-++\axiomOpFrom{e04dgf}{e04Package}, \axiomOpFrom{e04ucf}{e04Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)
-++      DOUBLE PRECISION X(N),OBJF,OBJGRD(N),USER(*)
-++      INTEGER N,IUSER(*),MODE,NSTATE
-++      OBJF=X(4)*X(9)+((-1.0D0*X(5))+X(3))*X(8)+((-1.0D0*X(3))+X(1))*X(7)
-++     &+(-1.0D0*X(2)*X(6))
-++      OBJGRD(1)=X(7)
-++      OBJGRD(2)=-1.0D0*X(6)
-++      OBJGRD(3)=X(8)+(-1.0D0*X(7))
-++      OBJGRD(4)=X(9)
-++      OBJGRD(5)=-1.0D0*X(8)
-++      OBJGRD(6)=-1.0D0*X(2)
-++      OBJGRD(7)=(-1.0D0*X(3))+X(1)
-++      OBJGRD(8)=(-1.0D0*X(5))+X(3)
-++      OBJGRD(9)=X(4)
-++      RETURN
-++      END
-++\end{verbatim}
+++e04dgf, e04ucf, for example:
+++
+++\tab{5}SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)\br
+++\tab{5}DOUBLE PRECISION X(N),OBJF,OBJGRD(N),USER(*)\br
+++\tab{5}INTEGER N,IUSER(*),MODE,NSTATE\br
+++\tab{5}OBJF=X(4)*X(9)+((-1.0D0*X(5))+X(3))*X(8)+((-1.0D0*X(3))+X(1))*X(7)\br
+++\tab{4}&+(-1.0D0*X(2)*X(6))\br
+++\tab{5}OBJGRD(1)=X(7)\br
+++\tab{5}OBJGRD(2)=-1.0D0*X(6)\br
+++\tab{5}OBJGRD(3)=X(8)+(-1.0D0*X(7))\br
+++\tab{5}OBJGRD(4)=X(9)\br
+++\tab{5}OBJGRD(5)=-1.0D0*X(8)\br
+++\tab{5}OBJGRD(6)=-1.0D0*X(2)\br
+++\tab{5}OBJGRD(7)=(-1.0D0*X(3))+X(1)\br
+++\tab{5}OBJGRD(8)=(-1.0D0*X(5))+X(3)\br
+++\tab{5}OBJGRD(9)=X(4)\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp49(name): Exports == Implementation where
   name : Symbol
@@ -5604,43 +5582,42 @@ Asp49(name): Exports == Implementation where
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp50} produces Fortran for Type 50 ASPs, needed for NAG routine 
-++\axiomOpFrom{e04fdf}{e04Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE LSFUN1(M,N,XC,FVECC)
-++      DOUBLE PRECISION FVECC(M),XC(N)
-++      INTEGER I,M,N
-++      FVECC(1)=((XC(1)-2.4D0)*XC(3)+(15.0D0*XC(1)-36.0D0)*XC(2)+1.0D0)/(
-++     &XC(3)+15.0D0*XC(2))
-++      FVECC(2)=((XC(1)-2.8D0)*XC(3)+(7.0D0*XC(1)-19.6D0)*XC(2)+1.0D0)/(X
-++     &C(3)+7.0D0*XC(2))
-++      FVECC(3)=((XC(1)-3.2D0)*XC(3)+(4.333333333333333D0*XC(1)-13.866666
-++     &66666667D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))
-++      FVECC(4)=((XC(1)-3.5D0)*XC(3)+(3.0D0*XC(1)-10.5D0)*XC(2)+1.0D0)/(X
-++     &C(3)+3.0D0*XC(2))
-++      FVECC(5)=((XC(1)-3.9D0)*XC(3)+(2.2D0*XC(1)-8.579999999999998D0)*XC
-++     &(2)+1.0D0)/(XC(3)+2.2D0*XC(2))
-++      FVECC(6)=((XC(1)-4.199999999999999D0)*XC(3)+(1.666666666666667D0*X
-++     &C(1)-7.0D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))
-++      FVECC(7)=((XC(1)-4.5D0)*XC(3)+(1.285714285714286D0*XC(1)-5.7857142
-++     &85714286D0)*XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))
-++      FVECC(8)=((XC(1)-4.899999999999999D0)*XC(3)+(XC(1)-4.8999999999999
-++     &99D0)*XC(2)+1.0D0)/(XC(3)+XC(2))
-++      FVECC(9)=((XC(1)-4.699999999999999D0)*XC(3)+(XC(1)-4.6999999999999
-++     &99D0)*XC(2)+1.285714285714286D0)/(XC(3)+XC(2))
-++      FVECC(10)=((XC(1)-6.8D0)*XC(3)+(XC(1)-6.8D0)*XC(2)+1.6666666666666
-++     &67D0)/(XC(3)+XC(2))
-++      FVECC(11)=((XC(1)-8.299999999999999D0)*XC(3)+(XC(1)-8.299999999999
-++     &999D0)*XC(2)+2.2D0)/(XC(3)+XC(2))
-++      FVECC(12)=((XC(1)-10.6D0)*XC(3)+(XC(1)-10.6D0)*XC(2)+3.0D0)/(XC(3)
-++     &+XC(2))
-++      FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333
-++     &3333D0)/(XC(3)+XC(2))
-++      FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X
-++     &C(2))
-++      FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3
-++     &)+XC(2))
-++      END
-++\end{verbatim}
+++e04fdf, for example:
+++
+++\tab{5}SUBROUTINE LSFUN1(M,N,XC,FVECC)\br
+++\tab{5}DOUBLE PRECISION FVECC(M),XC(N)\br
+++\tab{5}INTEGER I,M,N\br
+++\tab{5}FVECC(1)=((XC(1)-2.4D0)*XC(3)+(15.0D0*XC(1)-36.0D0)*XC(2)+1.0D0)/(\br
+++\tab{4}&XC(3)+15.0D0*XC(2))\br
+++\tab{5}FVECC(2)=((XC(1)-2.8D0)*XC(3)+(7.0D0*XC(1)-19.6D0)*XC(2)+1.0D0)/(X\br
+++\tab{4}&C(3)+7.0D0*XC(2))\br
+++\tab{5}FVECC(3)=((XC(1)-3.2D0)*XC(3)+(4.333333333333333D0*XC(1)-13.866666\br
+++\tab{4}&66666667D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))\br
+++\tab{5}FVECC(4)=((XC(1)-3.5D0)*XC(3)+(3.0D0*XC(1)-10.5D0)*XC(2)+1.0D0)/(X\br
+++\tab{4}&C(3)+3.0D0*XC(2))\br
+++\tab{5}FVECC(5)=((XC(1)-3.9D0)*XC(3)+(2.2D0*XC(1)-8.579999999999998D0)*XC\br
+++\tab{4}&(2)+1.0D0)/(XC(3)+2.2D0*XC(2))\br
+++\tab{5}FVECC(6)=((XC(1)-4.199999999999999D0)*XC(3)+(1.666666666666667D0*X\br
+++\tab{4}&C(1)-7.0D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))\br
+++\tab{5}FVECC(7)=((XC(1)-4.5D0)*XC(3)+(1.285714285714286D0*XC(1)-5.7857142\br
+++\tab{4}&85714286D0)*XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))\br
+++\tab{5}FVECC(8)=((XC(1)-4.899999999999999D0)*XC(3)+(XC(1)-4.8999999999999\br
+++\tab{4}&99D0)*XC(2)+1.0D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(9)=((XC(1)-4.699999999999999D0)*XC(3)+(XC(1)-4.6999999999999\br
+++\tab{4}&99D0)*XC(2)+1.285714285714286D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(10)=((XC(1)-6.8D0)*XC(3)+(XC(1)-6.8D0)*XC(2)+1.6666666666666\br
+++\tab{4}&67D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(11)=((XC(1)-8.299999999999999D0)*XC(3)+(XC(1)-8.299999999999\br
+++\tab{4}&999D0)*XC(2)+2.2D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(12)=((XC(1)-10.6D0)*XC(3)+(XC(1)-10.6D0)*XC(2)+3.0D0)/(XC(3)\br
+++\tab{4}&+XC(2))\br
+++\tab{5}FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333\br
+++\tab{4}&3333D0)/(XC(3)+XC(2))\br
+++\tab{5}FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X\br
+++\tab{4}&C(2))\br
+++\tab{5}FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3\br
+++\tab{4}&)+XC(2))\br
+++\tab{5}END
 
 Asp50(name): Exports == Implementation where
   name : Symbol
@@ -5783,42 +5760,41 @@ Asp50(name): Exports == Implementation where
 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory
 ++ Description:
 ++\spadtype{Asp55} produces Fortran for Type 55 ASPs, needed for NAG routines 
-++\axiomOpFrom{e04dgf}{e04Package} and \axiomOpFrom{e04ucf}{e04Package}, for example:
-++\begin{verbatim}
-++      SUBROUTINE CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,IUSER
-++     &,USER)
-++      DOUBLE PRECISION C(NCNLN),X(N),CJAC(NROWJ,N),USER(*)
-++      INTEGER N,IUSER(*),NEEDC(NCNLN),NROWJ,MODE,NCNLN,NSTATE
-++      IF(NEEDC(1).GT.0)THEN
-++        C(1)=X(6)**2+X(1)**2
-++        CJAC(1,1)=2.0D0*X(1)
-++        CJAC(1,2)=0.0D0
-++        CJAC(1,3)=0.0D0
-++        CJAC(1,4)=0.0D0
-++        CJAC(1,5)=0.0D0
-++        CJAC(1,6)=2.0D0*X(6)
-++      ENDIF
-++      IF(NEEDC(2).GT.0)THEN
-++        C(2)=X(2)**2+(-2.0D0*X(1)*X(2))+X(1)**2
-++        CJAC(2,1)=(-2.0D0*X(2))+2.0D0*X(1)
-++        CJAC(2,2)=2.0D0*X(2)+(-2.0D0*X(1))
-++        CJAC(2,3)=0.0D0
-++        CJAC(2,4)=0.0D0
-++        CJAC(2,5)=0.0D0
-++        CJAC(2,6)=0.0D0
-++      ENDIF
-++      IF(NEEDC(3).GT.0)THEN
-++        C(3)=X(3)**2+(-2.0D0*X(1)*X(3))+X(2)**2+X(1)**2
-++        CJAC(3,1)=(-2.0D0*X(3))+2.0D0*X(1)
-++        CJAC(3,2)=2.0D0*X(2)
-++        CJAC(3,3)=2.0D0*X(3)+(-2.0D0*X(1))
-++        CJAC(3,4)=0.0D0
-++        CJAC(3,5)=0.0D0
-++        CJAC(3,6)=0.0D0
-++      ENDIF
-++      RETURN
-++      END
-++\end{verbatim}
+++e04dgf and e04ucf, for example:
+++
+++\tab{5}SUBROUTINE CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,IUSER\br
+++\tab{4}&,USER)\br
+++\tab{5}DOUBLE PRECISION C(NCNLN),X(N),CJAC(NROWJ,N),USER(*)\br
+++\tab{5}INTEGER N,IUSER(*),NEEDC(NCNLN),NROWJ,MODE,NCNLN,NSTATE\br
+++\tab{5}IF(NEEDC(1).GT.0)THEN\br
+++\tab{7}C(1)=X(6)**2+X(1)**2\br
+++\tab{7}CJAC(1,1)=2.0D0*X(1)\br
+++\tab{7}CJAC(1,2)=0.0D0\br
+++\tab{7}CJAC(1,3)=0.0D0\br
+++\tab{7}CJAC(1,4)=0.0D0\br
+++\tab{7}CJAC(1,5)=0.0D0\br
+++\tab{7}CJAC(1,6)=2.0D0*X(6)\br
+++\tab{5}ENDIF\br
+++\tab{5}IF(NEEDC(2).GT.0)THEN\br
+++\tab{7}C(2)=X(2)**2+(-2.0D0*X(1)*X(2))+X(1)**2\br
+++\tab{7}CJAC(2,1)=(-2.0D0*X(2))+2.0D0*X(1)\br
+++\tab{7}CJAC(2,2)=2.0D0*X(2)+(-2.0D0*X(1))\br
+++\tab{7}CJAC(2,3)=0.0D0\br
+++\tab{7}CJAC(2,4)=0.0D0\br
+++\tab{7}CJAC(2,5)=0.0D0\br
+++\tab{7}CJAC(2,6)=0.0D0\br
+++\tab{5}ENDIF\br
+++\tab{5}IF(NEEDC(3).GT.0)THEN\br
+++\tab{7}C(3)=X(3)**2+(-2.0D0*X(1)*X(3))+X(2)**2+X(1)**2\br
+++\tab{7}CJAC(3,1)=(-2.0D0*X(3))+2.0D0*X(1)\br
+++\tab{7}CJAC(3,2)=2.0D0*X(2)\br
+++\tab{7}CJAC(3,3)=2.0D0*X(3)+(-2.0D0*X(1))\br
+++\tab{7}CJAC(3,4)=0.0D0\br
+++\tab{7}CJAC(3,5)=0.0D0\br
+++\tab{7}CJAC(3,6)=0.0D0\br
+++\tab{5}ENDIF\br
+++\tab{5}RETURN\br
+++\tab{5}END
 
 Asp55(name): Exports == Implementation where
   name : Symbol
@@ -6005,31 +5981,29 @@ Asp55(name): Exports == Implementation where
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description:
 ++ \spadtype{Asp6} produces Fortran for Type 6 ASPs, needed for NAG routines
-++ \axiomOpFrom{c05nbf}{c05Package}, \axiomOpFrom{c05ncf}{c05Package}.
-++ These represent vectors of functions of X(i) and look like:
-++ \begin{verbatim}
-++      SUBROUTINE FCN(N,X,FVEC,IFLAG)
-++      DOUBLE PRECISION X(N),FVEC(N)
-++      INTEGER N,IFLAG
-++      FVEC(1)=(-2.0D0*X(2))+(-2.0D0*X(1)**2)+3.0D0*X(1)+1.0D0
-++      FVEC(2)=(-2.0D0*X(3))+(-2.0D0*X(2)**2)+3.0D0*X(2)+(-1.0D0*X(1))+1.
-++     &0D0
-++      FVEC(3)=(-2.0D0*X(4))+(-2.0D0*X(3)**2)+3.0D0*X(3)+(-1.0D0*X(2))+1.
-++     &0D0
-++      FVEC(4)=(-2.0D0*X(5))+(-2.0D0*X(4)**2)+3.0D0*X(4)+(-1.0D0*X(3))+1.
-++     &0D0
-++      FVEC(5)=(-2.0D0*X(6))+(-2.0D0*X(5)**2)+3.0D0*X(5)+(-1.0D0*X(4))+1.
-++     &0D0
-++      FVEC(6)=(-2.0D0*X(7))+(-2.0D0*X(6)**2)+3.0D0*X(6)+(-1.0D0*X(5))+1.
-++     &0D0
-++      FVEC(7)=(-2.0D0*X(8))+(-2.0D0*X(7)**2)+3.0D0*X(7)+(-1.0D0*X(6))+1.
-++     &0D0
-++      FVEC(8)=(-2.0D0*X(9))+(-2.0D0*X(8)**2)+3.0D0*X(8)+(-1.0D0*X(7))+1.
-++     &0D0
-++      FVEC(9)=(-2.0D0*X(9)**2)+3.0D0*X(9)+(-1.0D0*X(8))+1.0D0
-++      RETURN
-++      END
-++ \end{verbatim}
+++ c05nbf, c05ncf. These represent vectors of functions of X(i) and look like:
+++ 
+++ \tab{5}SUBROUTINE FCN(N,X,FVEC,IFLAG)
+++ \tab{5}DOUBLE PRECISION X(N),FVEC(N)
+++ \tab{5}INTEGER N,IFLAG
+++ \tab{5}FVEC(1)=(-2.0D0*X(2))+(-2.0D0*X(1)**2)+3.0D0*X(1)+1.0D0
+++ \tab{5}FVEC(2)=(-2.0D0*X(3))+(-2.0D0*X(2)**2)+3.0D0*X(2)+(-1.0D0*X(1))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(3)=(-2.0D0*X(4))+(-2.0D0*X(3)**2)+3.0D0*X(3)+(-1.0D0*X(2))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(4)=(-2.0D0*X(5))+(-2.0D0*X(4)**2)+3.0D0*X(4)+(-1.0D0*X(3))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(5)=(-2.0D0*X(6))+(-2.0D0*X(5)**2)+3.0D0*X(5)+(-1.0D0*X(4))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(6)=(-2.0D0*X(7))+(-2.0D0*X(6)**2)+3.0D0*X(6)+(-1.0D0*X(5))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(7)=(-2.0D0*X(8))+(-2.0D0*X(7)**2)+3.0D0*X(7)+(-1.0D0*X(6))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(8)=(-2.0D0*X(9))+(-2.0D0*X(8)**2)+3.0D0*X(8)+(-1.0D0*X(7))+1.
+++ \tab{4}&0D0
+++ \tab{5}FVEC(9)=(-2.0D0*X(9)**2)+3.0D0*X(9)+(-1.0D0*X(8))+1.0D0
+++ \tab{5}RETURN
+++ \tab{5}END
 
 Asp6(name): Exports == Implementation where
   name : Symbol
@@ -6080,7 +6054,8 @@ Asp6(name): Exports == Implementation where
       v::$
 
     retractIfCan(u:VEC FRAC POLY FLOAT):Union($,"failed") ==
-      v:Union(VEC FEXPR,"failed"):=map(retractIfCan,u)$VF2(FRAC POLY FLOAT,FEXPR)
+      v:Union(VEC FEXPR,"failed"):=_
+        map(retractIfCan,u)$VF2(FRAC POLY FLOAT,FEXPR)
       v case "failed" => "failed"
       (v::VEC FEXPR)::$
 
@@ -6170,19 +6145,17 @@ Asp6(name): Exports == Implementation where
 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory
 ++ Description:
 ++ \spadtype{Asp7} produces Fortran for Type 7 ASPs, needed for NAG routines
-++ \axiomOpFrom{d02bbf}{d02Package}, \axiomOpFrom{d02gaf}{d02Package}.
-++ These represent a vector of functions of the scalar X and
+++ d02bb