diff --git a/books/bookvol10.3.pamphlet b/books/bookvol10.3.pamphlet
index 33e4bb1..4eaccf3 100644
--- a/books/bookvol10.3.pamphlet
+++ b/books/bookvol10.3.pamphlet
@@ -29,7 +29,7 @@
 \newcommand{\pagehead}[2]{% e.g. \pagehead{name}{abb}
 \dest{#1}%
 \dest{#2}%
-\subsection{{\bf #1} (#2)}
+\subsection{#1 (#2)}
 \label{#1}%
 \label{#2}%
 \index{{#1}}%
@@ -38,7 +38,7 @@
 %% pagepic adds an image and an index entry
 %%
 \newcommand{\pagepic}[3]{% e.g. \pagepic{pathandfile}{abb}{scale}
-\includegraphics[scale=#3]{#1}%
+\includegraphics[scale=#3]{#1}\\%
 \index{images!#2}}
 %%
 %% \refto is a link to a referenced page that returns it arg
@@ -283,6 +283,399 @@ November 10, 2003 ((iHy))
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Chapter A}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain ALGSC AlgebraGivenByStructuralConstants}
+\pagehead{AlgebraGivenByStructuralConstants}{ALGSC}
+\pagepic{ps/v103algebragivenbystructuralconstants.ps}{ALGSC}{1.00}
+<<domain ALGSC AlgebraGivenByStructuralConstants>>=
+)abbrev domain ALGSC AlgebraGivenByStructuralConstants
+++ Authors: J. Grabmeier, R. Wisbauer
+++ Date Created: 01 March 1991
+++ Date Last Updated: 22 January 1992
+++ Basic Operations:
+++ Related Constructors:
+++ Also See:
+++ AMS Classifications:
+++ Keywords: algebra, structural constants
+++ Reference:
+++  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(R:Field, n : PositiveInteger,_
+  ls : List Symbol, gamma: Vector Matrix R ): public == private where
+
+  V  ==> Vector
+  M  ==> Matrix
+  I  ==> Integer
+  NNI  ==> NonNegativeInteger
+  REC  ==> Record(particular: Union(V R,"failed"),basis: List V R)
+  LSMP ==> LinearSystemMatrixPackage(R,V R,V R, M R)
+
+  --public ==> FramedNonAssociativeAlgebra(R) with
+  public ==> Join(FramedNonAssociativeAlgebra(R), _
+    LeftModule(SquareMatrix(n,R)) ) with
+
+    coerce : Vector R -> %
+      ++ coerce(v) converts a vector to a member of the algebra
+      ++ by forming a linear combination with the basis element.
+      ++ Note: the vector is assumed to have length equal to the
+      ++ dimension of the algebra.
+
+  private ==> DirectProduct(n,R) add
+
+    Rep := DirectProduct(n,R)
+
+    x,y : %
+    dp : DirectProduct(n,R)
+    v : V R
+
+
+    recip(x) == recip(x)$FiniteRankNonAssociativeAlgebra_&(%,R)
+
+    (m:SquareMatrix(n,R))*(x:%) == apply((m :: Matrix R),x)
+    coerce v == directProduct(v) :: %
+
+    structuralConstants() == gamma
+
+    coordinates(x) == vector(entries(x :: Rep)$Rep)$Vector(R)
+
+    coordinates(x,b) ==
+      --not (maxIndex b = n) =>
+      --  error("coordinates: your 'basis' has not the right length")
+      m : NonNegativeInteger := (maxIndex b) :: NonNegativeInteger
+      transitionMatrix   : Matrix R := new(n,m,0$R)$Matrix(R)
+      for i in 1..m repeat
+        setColumn_!(transitionMatrix,i,coordinates(b.i))
+      res : REC := solve(transitionMatrix,coordinates(x))$LSMP
+      if (not every?(zero?$R,first res.basis)) then
+        error("coordinates: warning your 'basis' is linearly dependent")
+      (res.particular  case "failed") =>
+        error("coordinates: first argument is not in linear span of second argument")
+      (res.particular) :: (Vector R)
+
+    basis() == [unitVector(i::PositiveInteger)::% for i in 1..n]
+
+    someBasis() == basis()$%
+
+    rank() == n
+
+    elt(x,i) == elt(x:Rep,i)$Rep
+
+    coerce(x:%):OutputForm ==
+      zero?(x::Rep)$Rep => (0$R) :: OutputForm
+      le : List OutputForm := nil
+      for i in 1..n repeat
+        coef : R := elt(x::Rep,i)
+        not zero?(coef)$R =>
+--          one?(coef)$R =>
+          ((coef) = 1)$R =>
+            -- sy : OutputForm := elt(ls,i)$(List Symbol) :: OutputForm
+            le := cons(elt(ls,i)$(List Symbol) :: OutputForm, le)
+          le := cons(coef :: OutputForm *  elt(ls,i)$(List Symbol)_
+              :: OutputForm, le)
+      reduce("+",le)
+
+    x * y ==
+      v : Vector R :=  new(n,0)
+      for k in 1..n repeat
+        h : R := 0
+        for i in 1..n repeat
+          for j in 1..n repeat
+            h := h  +$R elt(x,i) *$R elt(y,j) *$R elt(gamma.k,i,j )
+        v.k := h
+      directProduct v
+
+
+
+    alternative?() ==
+      for i in 1..n repeat
+        -- expression for check of left alternative is symmetric in i and j:
+        -- expression for check of right alternative is symmetric in j and k:
+        for j in 1..i-1 repeat
+          for k in j..n repeat
+            -- right check
+            for r in 1..n repeat
+              res := 0$R
+              for l in 1..n repeat
+                res := res - _
+                  (elt(gamma.l,j,k)+elt(gamma.l,k,j))*elt(gamma.r,i,l)+_
+                  (elt(gamma.l,i,j)*elt(gamma.r,l,k) + elt(gamma.l,i,k)*_
+                  elt(gamma.r,l,j) )
+              not zero? res =>
+                messagePrint("algebra is not right alternative")$OutputForm
+                return false
+        for j in i..n repeat
+          for k in 1..j-1 repeat
+            -- left check
+            for r in 1..n repeat
+              res := 0$R
+              for l in 1..n repeat
+                res := res + _
+                  (elt(gamma.l,i,j)+elt(gamma.l,j,i))*elt(gamma.r,l,k)-_
+                  (elt(gamma.l,j,k)*elt(gamma.r,i,l) + elt(gamma.l,i,k)*_
+                   elt(gamma.r,j,l) )
+              not (zero? res) =>
+                messagePrint("algebra is not left alternative")$OutputForm
+                return false
+
+          for k in j..n repeat
+            -- left check
+            for r in 1..n repeat
+              res := 0$R
+              for l in 1..n repeat
+                res := res + _
+                  (elt(gamma.l,i,j)+elt(gamma.l,j,i))*elt(gamma.r,l,k)-_
+                  (elt(gamma.l,j,k)*elt(gamma.r,i,l) + elt(gamma.l,i,k)*_
+                   elt(gamma.r,j,l) )
+              not (zero? res) =>
+                messagePrint("algebra is not left alternative")$OutputForm
+                return false
+            -- right check
+            for r in 1..n repeat
+              res := 0$R
+              for l in 1..n repeat
+                res := res - _
+                  (elt(gamma.l,j,k)+elt(gamma.l,k,j))*elt(gamma.r,i,l)+_
+                  (elt(gamma.l,i,j)*elt(gamma.r,l,k) + elt(gamma.l,i,k)*_
+                  elt(gamma.r,l,j) )
+              not (zero? res) =>
+                messagePrint("algebra is not right alternative")$OutputForm
+                return false
+
+      messagePrint("algebra satisfies 2*associator(a,b,b) = 0 = 2*associator(a,a,b) = 0")$OutputForm
+      true
+
+    -- should be in the category, but is not exported
+--    conditionsForIdempotents b  ==
+--      n := rank()
+--      --gamma : Vector Matrix R := structuralConstants b
+--      listOfNumbers : List String :=  [STRINGIMAGE(q)$Lisp for q in 1..n]
+--      symbolsForCoef : Vector Symbol :=
+--        [concat("%", concat("x", i))::Symbol  for i in listOfNumbers]
+--      conditions : List Polynomial R := []
+ --     for k in 1..n repeat
+ --       xk := symbolsForCoef.k
+ --       p : Polynomial R :=  monomial( - 1$Polynomial(R), [xk], [1] )
+ --       for i in 1..n repeat
+ --         for j in 1..n repeat
+ --           xi := symbolsForCoef.i
+ --           xj := symbolsForCoef.j
+ --           p := p + monomial(_
+ --             elt((gamma.k),i,j) :: Polynomial(R), [xi,xj], [1,1])
+ --       conditions := cons(p,conditions)
+ --     conditions
+
+    associative?() ==
+      for i in 1..n repeat
+       for j in 1..n repeat
+        for k in 1..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+             res := res + elt(gamma.l,i,j)*elt(gamma.r,l,k)-_
+                          elt(gamma.l,j,k)*elt(gamma.r,i,l)
+           not (zero? res) =>
+            messagePrint("algebra is not associative")$OutputForm
+            return false
+      messagePrint("algebra is associative")$OutputForm
+      true
+
+
+    antiAssociative?() ==
+      for i in 1..n repeat
+       for j in 1..n repeat
+        for k in 1..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+             res := res + elt(gamma.l,i,j)*elt(gamma.r,l,k)+_
+                          elt(gamma.l,j,k)*elt(gamma.r,i,l)
+           not (zero? res) =>
+            messagePrint("algebra is not anti-associative")$OutputForm
+            return false
+      messagePrint("algebra is anti-associative")$OutputForm
+      true
+
+    commutative?() ==
+      for i in 1..n repeat
+       for j in (i+1)..n repeat
+        for k in 1..n repeat
+           not ( elt(gamma.k,i,j)=elt(gamma.k,j,i) ) =>
+            messagePrint("algebra is not commutative")$OutputForm
+            return false
+      messagePrint("algebra is commutative")$OutputForm
+      true
+
+    antiCommutative?() ==
+      for i in 1..n repeat
+       for j in i..n repeat
+        for k in 1..n repeat
+          not zero? (i=j => elt(gamma.k,i,i); elt(gamma.k,i,j)+elt(gamma.k,j,i) ) =>
+            messagePrint("algebra is not anti-commutative")$OutputForm
+            return false
+      messagePrint("algebra is anti-commutative")$OutputForm
+      true
+
+    leftAlternative?() ==
+      for i in 1..n repeat
+       -- expression is symmetric in i and j:
+       for j in i..n repeat
+        for k in 1..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+             res := res + (elt(gamma.l,i,j)+elt(gamma.l,j,i))*elt(gamma.r,l,k)-_
+               (elt(gamma.l,j,k)*elt(gamma.r,i,l) + elt(gamma.l,i,k)*elt(gamma.r,j,l) )
+           not (zero? res) =>
+            messagePrint("algebra is not left alternative")$OutputForm
+            return false
+      messagePrint("algebra is left alternative")$OutputForm
+      true
+
+
+    rightAlternative?() ==
+      for i in 1..n repeat
+       for j in 1..n repeat
+       -- expression is symmetric in j and k:
+        for k in j..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+             res := res - (elt(gamma.l,j,k)+elt(gamma.l,k,j))*elt(gamma.r,i,l)+_
+               (elt(gamma.l,i,j)*elt(gamma.r,l,k) + elt(gamma.l,i,k)*elt(gamma.r,l,j) )
+           not (zero? res) =>
+            messagePrint("algebra is not right alternative")$OutputForm
+            return false
+      messagePrint("algebra is right alternative")$OutputForm
+      true
+
+
+    flexible?() ==
+      for i in 1..n repeat
+       for j in 1..n repeat
+       -- expression is symmetric in i and k:
+        for k in i..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+             res := res + elt(gamma.l,i,j)*elt(gamma.r,l,k)-_
+                          elt(gamma.l,j,k)*elt(gamma.r,i,l)+_
+                          elt(gamma.l,k,j)*elt(gamma.r,l,i)-_
+                          elt(gamma.l,j,i)*elt(gamma.r,k,l)
+           not (zero? res) =>
+            messagePrint("algebra is not flexible")$OutputForm
+            return false
+      messagePrint("algebra is flexible")$OutputForm
+      true
+
+    lieAdmissible?() ==
+      for i in 1..n repeat
+       for j in 1..n repeat
+        for k in 1..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+             res := res_
+              + (elt(gamma.l,i,j)-elt(gamma.l,j,i))*(elt(gamma.r,l,k)-elt(gamma.r,k,l)) _
+              + (elt(gamma.l,j,k)-elt(gamma.l,k,j))*(elt(gamma.r,l,i)-elt(gamma.r,i,l)) _
+              + (elt(gamma.l,k,i)-elt(gamma.l,i,k))*(elt(gamma.r,l,j)-elt(gamma.r,j,l))
+           not (zero? res) =>
+            messagePrint("algebra is not Lie admissible")$OutputForm
+            return false
+      messagePrint("algebra is Lie admissible")$OutputForm
+      true
+
+    jordanAdmissible?()  ==
+      recip(2 * 1$R) case "failed" =>
+        messagePrint("this algebra is not Jordan admissible, as 2 is not invertible in the ground ring")$OutputForm
+        false
+      for i in 1..n repeat
+       for j in 1..n repeat
+        for k in 1..n repeat
+         for w in 1..n repeat
+          for t in 1..n repeat
+           res := 0$R
+           for l in 1..n repeat
+            for r in 1..n repeat
+             res := res_
+              + (elt(gamma.l,i,j)+elt(gamma.l,j,i))_
+                * (elt(gamma.r,w,k)+elt(gamma.r,k,w))_
+                * (elt(gamma.t,l,r)+elt(gamma.t,r,l))_
+              - (elt(gamma.r,w,k)+elt(gamma.r,k,w))_
+                * (elt(gamma.l,j,r)+elt(gamma.l,r,j))_
+                * (elt(gamma.t,i,l)+elt(gamma.t,l,i))_
+              + (elt(gamma.l,w,j)+elt(gamma.l,j,w))_
+                * (elt(gamma.r,k,i)+elt(gamma.r,i,k))_
+                * (elt(gamma.t,l,r)+elt(gamma.t,r,l))_
+              - (elt(gamma.r,k,i)+elt(gamma.r,k,i))_
+                * (elt(gamma.l,j,r)+elt(gamma.l,r,j))_
+                * (elt(gamma.t,w,l)+elt(gamma.t,l,w))_
+              + (elt(gamma.l,k,j)+elt(gamma.l,j,k))_
+                * (elt(gamma.r,i,w)+elt(gamma.r,w,i))_
+                * (elt(gamma.t,l,r)+elt(gamma.t,r,l))_
+              - (elt(gamma.r,i,w)+elt(gamma.r,w,i))_
+                * (elt(gamma.l,j,r)+elt(gamma.l,r,j))_
+                * (elt(gamma.t,k,l)+elt(gamma.t,l,k))
+           not (zero? res) =>
+             messagePrint("algebra is not Jordan admissible")$OutputForm
+             return false
+      messagePrint("algebra is Jordan admissible")$OutputForm
+      true
+
+    jordanAlgebra?()  ==
+      recip(2 * 1$R) case "failed" =>
+        messagePrint("this is not a Jordan algebra, as 2 is not invertible in the ground ring")$OutputForm
+        false
+      not commutative?() =>
+        messagePrint("this is not a Jordan algebra")$OutputForm
+        false
+      for i in 1..n repeat
+       for j in 1..n repeat
+        for k in 1..n repeat
+         for l in 1..n repeat
+           for t in 1..n repeat
+             res := 0$R
+             for r in 1..n repeat
+               for s in 1..n repeat
+                 res := res +  _
+                   elt(gamma.r,i,j)*elt(gamma.s,l,k)*elt(gamma.t,r,s) - _
+                   elt(gamma.r,l,k)*elt(gamma.s,j,r)*elt(gamma.t,i,s) + _
+                   elt(gamma.r,l,j)*elt(gamma.s,k,k)*elt(gamma.t,r,s) - _
+                   elt(gamma.r,k,i)*elt(gamma.s,j,r)*elt(gamma.t,l,s) + _
+                   elt(gamma.r,k,j)*elt(gamma.s,i,k)*elt(gamma.t,r,s) - _
+                   elt(gamma.r,i,l)*elt(gamma.s,j,r)*elt(gamma.t,k,s)
+                 not zero? res =>
+                   messagePrint("this is not a Jordan algebra")$OutputForm
+                   return false
+      messagePrint("this is a Jordan algebra")$OutputForm
+      true
+
+
+    jacobiIdentity?()  ==
+      for i in 1..n repeat
+       for j in 1..n repeat
+        for k in 1..n repeat
+         for r in 1..n repeat
+           res := 0$R
+           for s in 1..n repeat
+                 res := res +  elt(gamma.r,i,j)*elt(gamma.s,j,k) +_
+                               elt(gamma.r,j,k)*elt(gamma.s,k,i) +_
+                               elt(gamma.r,k,i)*elt(gamma.s,i,j)
+           not zero? res =>
+                 messagePrint("Jacobi identity does not hold")$OutputForm
+                 return false
+      messagePrint("Jacobi identity holds")$OutputForm
+      true
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain ALGFF AlgebraicFunctionField}
 \pagehead{AlgebraicFunctionField}{ALGFF}
 \pagepic{ps/v103algebraicfunctionfield.ps}{ALGFF}{1.00}
@@ -5571,6 +5964,67 @@ AssociationList(Key:SetCategory, Entry:SetCategory):
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain AUTOMOR Automorphism}
+\pagehead{Automorphism}{AUTOMOR}
+\pagepic{ps/v103automorphism.ps}{AUTOMOR}{1.00}
+See also:\\
+\refto{SparseUnivariateSkewPolynomial}{ORESUP}
+\refto{UnivariateSkewPolynomial}{OREUP}
+<<domain AUTOMOR Automorphism>>=
+)abbrev domain AUTOMOR Automorphism
+++ Author: Manuel Bronstein
+++ Date Created: 31 January 1994
+++ Date Last Updated: 31 January 1994
+++ References:
+++ Description:
+++       Automorphism R is the multiplicative group of automorphisms of R.
+-- In fact, non-invertible endomorphism are allowed as partial functions.
+-- This domain is noncanonical in that f*f^{-1} will be the identity
+-- function but won't be equal to 1.
+Automorphism(R:Ring): Join(Group, Eltable(R, R)) with
+      morphism: (R -> R) -> %
+        ++ morphism(f) returns the non-invertible morphism given by f.
+      morphism: (R -> R, R -> R) -> %
+        ++ morphism(f, g) returns the invertible morphism given by f, where
+        ++ g is the inverse of f..
+      morphism: ((R, Integer) -> R) -> %
+        ++ morphism(f) returns the morphism given by \spad{f^n(x) = f(x,n)}.
+   == add
+      err:   R -> R
+      ident: (R, Integer) -> R
+      iter:  (R -> R, NonNegativeInteger, R) -> R
+      iterat: (R -> R, R -> R, Integer, R) -> R
+      apply: (%, R, Integer) -> R
+ 
+      Rep := ((R, Integer) -> R)
+ 
+      1                               == ident
+      err r                           == error "Morphism is not invertible"
+      ident(r, n)                     == r
+      f = g                           == EQ(f, g)$Lisp
+      elt(f, r)                       == apply(f, r, 1)
+      inv f                           == apply(f, #1, - #2)
+      f ** n                          == apply(f, #1, n * #2)
+      coerce(f:%):OutputForm          == message("R -> R")
+      morphism(f:(R, Integer) -> R):% == f
+      morphism(f:R -> R):%            == morphism(f, err)
+      morphism(f, g)                  == iterat(f, g, #2, #1)
+      apply(f, r, n) == (g := f pretend ((R, Integer) -> R); g(r, n))
+ 
+      iterat(f, g, n, r) ==
+          n < 0 => iter(g, (-n)::NonNegativeInteger, r)
+          iter(f, n::NonNegativeInteger, r)
+ 
+      iter(f, n, r) ==
+          for i in 1..n repeat r := f r
+          r
+ 
+      f * g ==
+        f = g => f**2
+        iterat(f g #1, (inv g)(inv f) #1, #2, #1)
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Chapter B}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain BFUNCT BasicFunctions}
@@ -5642,6 +6096,494 @@ BasicFunctions():  E == I where
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain BOP BasicOperator}
+<<BasicOperator.input>>=
+-- op.spad.pamphlet BasicOperator.input
+)spool BasicOperator.output
+)set message test on
+)set message auto off
+)clear all
+--S 1 of 18
+y := operator 'y
+--R 
+--R
+--R   (1)  y
+--R                                                          Type: BasicOperator
+--E 1
+
+--S 2 of 18
+deq := D(y x, x, 2) + D(y x, x) + y x = 0
+--R 
+--R
+--R         ,,       ,
+--R   (2)  y  (x) + y (x) + y(x)= 0
+--R
+--R                                            Type: Equation Expression Integer
+--E 2
+
+--S 3 of 18
+solve(deq, y, x)
+--R 
+--R
+--R                                             x     x
+--R                                     +-+   - -   - -      +-+
+--R                                   x\|3      2     2    x\|3
+--R   (3)  [particular= 0,basis= [cos(-----)%e   ,%e   sin(-----)]]
+--R                                     2                    2
+--RType: Union(Record(particular: Expression Integer,basis: List Expression Integer),...)
+--E 3
+
+--S 4 of 18
+nary? y
+--R 
+--R
+--R   (4)  true
+--R                                                                Type: Boolean
+--E 4
+
+--S 5 of 18
+unary? y
+--R 
+--R
+--R   (5)  false
+--R                                                                Type: Boolean
+--E 5
+
+--S 6 of 18
+opOne := operator('opOne, 1)
+--R 
+--R
+--R   (6)  opOne
+--R                                                          Type: BasicOperator
+--E 6
+
+--S 7 of 18
+nary? opOne
+--R 
+--R
+--R   (7)  false
+--R                                                                Type: Boolean
+--E 7
+
+--S 8 of 18
+unary? opOne
+--R 
+--R
+--R   (8)  true
+--R                                                                Type: Boolean
+--E 8
+
+--S 9 of 18
+arity opOne
+--R 
+--R
+--R   (9)  1
+--R                                          Type: Union(NonNegativeInteger,...)
+--E 9
+
+--S 10 of 18
+name opOne
+--R 
+--R
+--R   (10)  opOne
+--R                                                                 Type: Symbol
+--E 10
+
+--S 11 of 18
+is?(opOne, 'z2)
+--R 
+--R
+--R   (11)  false
+--R                                                                Type: Boolean
+--E 11
+
+--S 12 of 18
+is?(opOne, "opOne")
+--R 
+--R
+--R   (12)  true
+--R                                                                Type: Boolean
+--E 12
+
+--S 13 of 18
+properties y
+--R 
+--R
+--R   (13)  table()
+--R                                           Type: AssociationList(String,None)
+--E 13
+
+--S 14 of 18
+setProperty(y, "use", "unknown function" :: None )
+--R 
+--R
+--R   (14)  y
+--R                                                          Type: BasicOperator
+--E 14
+
+--S 15 of 18
+properties y
+--R 
+--R
+--R   (15)  table("use"= NONE)
+--R                                           Type: AssociationList(String,None)
+--E 15
+
+--S 16 of 18
+property(y, "use") :: None pretend String
+--R 
+--R
+--R   (16)  "unknown function"
+--R                                                                 Type: String
+--E 16
+
+--S 17 of 18
+deleteProperty!(y, "use")
+--R 
+--R
+--R   (17)  y
+--R                                                          Type: BasicOperator
+--E 17
+
+--S 18 of 18
+properties y
+--R 
+--R
+--R   (18)  table()
+--R                                           Type: AssociationList(String,None)
+--E 18
+)spool
+)lisp (bye)
+@
+<<BasicOperator.help>>=
+====================================================================
+BasicOperator examples
+====================================================================
+
+A basic operator is an object that can be symbolically applied to a
+list of arguments from a set, the result being a kernel over that set
+or an expression.  
+
+You create an object of type BasicOperator by using the operator
+operation.  This first form of this operation has one argument and it
+must be a symbol.  The symbol should be quoted in case the name has
+been used as an identifier to which a value has been assigned.
+
+A frequent application of BasicOperator is the creation of an operator
+to represent the unknown function when solving a differential equation.
+
+Let y be the unknown function in terms of x.
+
+  y := operator 'y
+   y 
+                      Type: BasicOperator
+
+This is how you enter the equation y'' + y' + y = 0.
+
+  deq := D(y x, x, 2) + D(y x, x) + y x = 0
+    ,,       ,
+   y  (x) + y (x) + y(x) = 0
+                      Type: Equation Expression Integer
+
+To solve the above equation, enter this.
+
+  solve(deq, y, x)
+                                        x     x
+                                +-+   - -   - -      +-+
+                              x\|3      2     2    x\|3
+   [particular= 0,basis= [cos(-----)%e   ,%e   sin(-----)]]
+                                2                    2
+                      Type: Union(Record(particular: Expression Integer,
+                                  basis: List Expression Integer),...)
+
+Use the single argument form of BasicOperator (as above) when you
+intend to use the operator to create functional expressions with an
+arbitrary number of arguments
+
+Nary means an arbitrary number of arguments can be used in the
+functional expressions.
+
+  nary? y
+   true
+                      Type: Boolean
+
+  unary? y
+   false
+                      Type: Boolean
+
+Use the two-argument form when you want to restrict the number of
+arguments in the functional expressions created with the operator.
+
+This operator can only be used to create functional expressions
+with one argument.
+
+  opOne := operator('opOne, 1)
+   opOne 
+                      Type: BasicOperator
+
+  nary? opOne
+   false
+                      Type: Boolean
+
+  unary? opOne
+   true
+                      Type: Boolean
+
+Use arity to learn the number of arguments that can be used.  It
+returns "false" if the operator is nary.
+
+  arity opOne
+   1
+                      Type: Union(NonNegativeInteger,...)
+
+Use name to learn the name of an operator.
+
+  name opOne
+   opOne 
+                      Type: Symbol
+
+Use is? to learn if an operator has a particular name.
+
+  is?(opOne, 'z2)
+   false
+                      Type: Boolean
+
+You can also use a string as the name to be tested against.
+
+  is?(opOne, "opOne")
+   true
+                      Type: Boolean
+
+You can attached named properties to an operator.  These are rarely
+used at the top-level of the Axiom interactive environment but are
+used with Axiom library source code.
+
+By default, an operator has no properties.
+
+  properties y
+   table() 
+                      Type: AssociationList(String,None)
+
+The interface for setting and getting properties is somewhat awkward
+because the property values are stored as values of type None.
+
+Attach a property by using setProperty.
+
+  setProperty(y, "use", "unknown function" :: None )
+   y 
+                      Type: BasicOperator
+
+  properties y
+   table("use"=NONE)
+                      Type: AssociationList(String,None)
+
+We know the property value has type String.
+
+  property(y, "use") :: None pretend String
+   "unknown function"
+                      Type: String
+
+Use deleteProperty! to destructively remove a property.
+
+ deleteProperty!(y, "use")
+  y 
+                      Type: BasicOperator
+
+  properties y
+   table() 
+                      Type: AssociationList(String,None)
+
+
+See Also
+o )help Expression
+o )help Kernel
+o )show BasicOperator
+o $AXIOM/doc/src/algebra/op.spad.dvi
+
+@
+\pagehead{BasicOperator}{BOP}
+\pagepic{ps/v103basicoperator.ps}{BOP}{1.00}
+<<domain BOP BasicOperator>>=
+)abbrev domain BOP BasicOperator
+++ Basic system operators
+++ Author: Manuel Bronstein
+++ Date Created: 22 March 1988
+++ Date Last Updated: 11 October 1993
+++ Description:
+++   A basic operator is an object that can be applied to a list of
+++   arguments from a set, the result being a kernel over that set.
+++ Keywords: operator, kernel.
+BasicOperator(): Exports == Implementation where
+  O   ==> OutputForm
+  P   ==> AssociationList(String, None)
+  L   ==> List Record(key:String, entry:None)
+  SEX ==> InputForm
+-- some internal properties
+  LESS?   ==> "%less?"
+  EQUAL?  ==> "%equal?"
+  WEIGHT  ==> "%weight"
+  DISPLAY ==> "%display"
+  SEXPR   ==> "%input"
+
+  Exports ==> OrderedSet with
+    name      : $ -> Symbol
+      ++ name(op) returns the name of op.
+    properties: $ -> P
+      ++ properties(op) returns the list of all the properties
+      ++ currently attached to op.
+    copy      : $ -> $
+      ++ copy(op) returns a copy of op.
+    operator  : Symbol -> $
+      ++ operator(f) makes f into an operator with arbitrary arity.
+    operator  : (Symbol, NonNegativeInteger) -> $
+      ++ operator(f, n) makes f into an n-ary operator.
+    arity     : $ -> Union(NonNegativeInteger, "failed")
+      ++ arity(op) returns n if op is n-ary, and
+      ++ "failed" if op has arbitrary arity.
+    nullary?  : $ -> Boolean
+      ++ nullary?(op) tests if op is nullary.
+    unary?    : $ -> Boolean
+      ++ unary?(op) tests if op is unary.
+    nary?     : $ -> Boolean
+      ++ nary?(op) tests if op has arbitrary arity.
+    weight    : $ -> NonNegativeInteger
+      ++ weight(op) returns the weight attached to op.
+    weight    : ($, NonNegativeInteger) -> $
+      ++ weight(op, n) attaches the weight n to op.
+    equality   : ($, ($, $) -> Boolean) -> $
+      ++ equality(op, foo?) attaches foo? as the "%equal?" property
+      ++ to op. If op1 and op2 have the same name, and one of them
+      ++ has an "%equal?" property f, then \spad{f(op1, op2)} is called to
+      ++ decide whether op1 and op2 should be considered equal.
+    comparison : ($, ($, $) -> Boolean) -> $
+      ++ comparison(op, foo?) attaches foo? as the "%less?" property
+      ++ to op. If op1 and op2 have the same name, and one of them
+      ++ has a "%less?" property f, then \spad{f(op1, op2)} is called to
+      ++ decide whether \spad{op1 < op2}.
+    display    : $ -> Union(List O -> O, "failed")
+      ++ display(op) returns the "%display" property of op if
+      ++ it has one attached, and "failed" otherwise.
+    display    : ($, List O -> O)      -> $
+      ++ display(op, foo) attaches foo as the "%display" property
+      ++ of op. If op has a "%display" property f, then \spad{op(a1,...,an)}
+      ++ gets converted to OutputForm as \spad{f(a1,...,an)}.
+    display    : ($, O -> O)           -> $
+      ++ display(op, foo) attaches foo as the "%display" property
+      ++ of op. If op has a "%display" property f, then \spad{op(a)}
+      ++ gets converted to OutputForm as \spad{f(a)}.
+      ++ Argument op must be unary.
+    input      : ($, List SEX -> SEX)  -> $
+      ++ input(op, foo) attaches foo as the "%input" property
+      ++ of op. If op has a "%input" property f, then \spad{op(a1,...,an)}
+      ++ gets converted to InputForm as \spad{f(a1,...,an)}.
+    input      : $ -> Union(List SEX -> SEX, "failed")
+      ++ input(op) returns the "%input" property of op if
+      ++ it has one attached, "failed" otherwise.
+    is?        : ($, Symbol) -> Boolean
+      ++ is?(op, s) tests if the name of op is s.
+    has?       : ($, String) -> Boolean
+      ++ has?(op, s) tests if property s is attached to op.
+    assert     : ($, String) -> $
+      ++ assert(op, s) attaches property s to op.
+      ++ Argument op is modified "in place", i.e. no copy is made.
+    deleteProperty_!: ($, String) -> $
+      ++ deleteProperty!(op, s) unattaches property s from op.
+      ++ Argument op is modified "in place", i.e. no copy is made.
+    property      : ($, String) -> Union(None, "failed")
+      ++ property(op, s) returns the value of property s if
+      ++ it is attached to op, and "failed" otherwise.
+    setProperty   : ($, String, None) -> $
+      ++ setProperty(op, s, v) attaches property s to op,
+      ++ and sets its value to v.
+      ++ Argument op is modified "in place", i.e. no copy is made.
+    setProperties : ($, P) -> $
+      ++ setProperties(op, l) sets the property list of op to l.
+      ++ Argument op is modified "in place", i.e. no copy is made.
+
+  Implementation ==> add
+    -- if narg < 0 then the operator has variable arity.
+    Rep := Record(opname:Symbol, narg:SingleInteger, props:P)
+
+    oper: (Symbol, SingleInteger, P) -> $
+
+    is?(op, s)           == name(op) = s
+    name op              == op.opname
+    properties op        == op.props
+    setProperties(op, l) == (op.props := l; op)
+    operator s           == oper(s, -1::SingleInteger, table())
+    operator(s, n)       == oper(s, n::Integer::SingleInteger, table())
+    property(op, name)   == search(name, op.props)
+    assert(op, s)        == setProperty(op, s, NIL$Lisp)
+    has?(op, name)       == key?(name, op.props)
+    oper(se, n, prop)    == [se, n, prop]
+    weight(op, n)        == setProperty(op, WEIGHT, n pretend None)
+    nullary? op          == zero?(op.narg)
+--    unary? op            == one?(op.narg)
+    unary? op            == ((op.narg) = 1)
+    nary? op             == negative?(op.narg)
+    equality(op, func)   == setProperty(op, EQUAL?, func pretend None)
+    comparison(op, func) == setProperty(op, LESS?, func pretend None)
+    display(op:$, f:O -> O)        == display(op, f first #1)
+    deleteProperty_!(op, name)     == (remove_!(name, properties op); op)
+    setProperty(op, name, valu)    == (op.props.name := valu; op)
+    coerce(op:$):OutputForm        == name(op)::OutputForm
+    input(op:$, f:List SEX -> SEX) == setProperty(op, SEXPR, f pretend None)
+    display(op:$, f:List O -> O)   == setProperty(op, DISPLAY, f pretend None)
+
+    display op ==
+      (u := property(op, DISPLAY)) case "failed" => "failed"
+      (u::None) pretend (List O -> O)
+
+    input op ==
+      (u := property(op, SEXPR)) case "failed" => "failed"
+      (u::None) pretend (List SEX -> SEX)
+
+    arity op ==
+      negative?(n := op.narg) => "failed"
+      convert(n)@Integer :: NonNegativeInteger
+
+    copy op ==
+      oper(name op, op.narg,
+          table([[r.key, r.entry] for r in entries(properties op)@L]$L))
+
+-- property EQUAL? contains a function f: (BOP, BOP) -> Boolean
+-- such that f(o1, o2) is true iff o1 = o2
+    op1 = op2 ==
+      (EQ$Lisp)(op1, op2) => true
+      name(op1) ^= name(op2) => false
+      op1.narg ^= op2.narg => false
+      brace(keys properties op1)^=$Set(String) _
+                     brace(keys properties op2) => false
+      (func := property(op1, EQUAL?)) case None =>
+                   ((func::None) pretend (($, $) -> Boolean)) (op1, op2)
+      true
+
+-- property WEIGHT allows one to change the ordering around
+-- by default, every operator has weigth 1
+    weight op ==
+      (w := property(op, WEIGHT)) case "failed" => 1
+      (w::None) pretend NonNegativeInteger
+
+-- property LESS? contains a function f: (BOP, BOP) -> Boolean
+-- such that f(o1, o2) is true iff o1 < o2
+    op1 < op2 ==
+      (w1 := weight op1) ^= (w2 := weight op2) => w1 < w2
+      op1.narg ^= op2.narg => op1.narg < op2.narg
+      name(op1) ^= name(op2) => name(op1) < name(op2)
+      n1 := #(k1 := brace(keys(properties op1))$Set(String))
+      n2 := #(k2 := brace(keys(properties op2))$Set(String))
+      n1 ^= n2 => n1 < n2
+      not zero?(n1 := #(d1 := difference(k1, k2))) =>
+        n1 ^= (n2 := #(d2 := difference(k2, k1))) => n1 < n2
+        inspect(d1) < inspect(d2)
+      (func := property(op1, LESS?)) case None =>
+                   ((func::None) pretend (($, $) -> Boolean)) (op1, op2)
+      (func := property(op1, EQUAL?)) case None =>
+              not(((func::None) pretend (($, $) -> Boolean)) (op1, op2))
+      false
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain BINFILE BinaryFile}
 \pagehead{BinaryFile}{BINFILE}
 \pagepic{ps/v103binaryfile.ps}{BINFILE}{1.00}
@@ -37007,6 +37949,239 @@ ModuleMonomial(IS: OrderedSet,
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain MODOP ModuleOperator}
+\pagehead{ModuleOperator}{MODOP}
+\pagepic{ps/v103moduleoperator.ps}{MODOP}{1.00}
+See also:\\
+\refto{Operator}{OP}
+<<domain MODOP ModuleOperator>>=
+)abbrev domain MODOP ModuleOperator
+++ Author: Manuel Bronstein
+++ Date Created: 15 May 1990
+++ Date Last Updated: 17 June 1993
+++ Description:
+++ Algebra of ADDITIVE operators on a module.
+ModuleOperator(R: Ring, M:LeftModule(R)): Exports == Implementation where
+  O    ==> OutputForm
+  OP   ==> BasicOperator
+  FG   ==> FreeGroup OP
+  RM   ==> Record(coef:R, monom:FG)
+  TERM ==> List RM
+  FAB  ==> FreeAbelianGroup TERM
+  OPADJ   ==> "%opAdjoint"
+  OPEVAL  ==> "%opEval"
+  INVEVAL ==> "%invEval"
+
+  Exports ==> Join(Ring, RetractableTo R, RetractableTo OP,
+                   Eltable(M, M)) with
+    if R has CharacteristicZero then CharacteristicZero
+    if R has CharacteristicNonZero then CharacteristicNonZero
+    if R has CommutativeRing then
+      Algebra(R)
+      adjoint: $ -> $
+        ++ adjoint(op) returns the adjoint of the operator \spad{op}.
+      adjoint: ($, $) -> $
+        ++ adjoint(op1, op2) sets the adjoint of op1 to be op2.
+        ++ op1 must be a basic operator
+      conjug  : R -> R
+        ++ conjug(x)should be local but conditional
+    evaluate: ($, M -> M) -> $
+      ++ evaluate(f, u +-> g u) attaches the map g to f.
+      ++ f must be a basic operator
+      ++ g MUST be additive, i.e. \spad{g(a + b) = g(a) + g(b)} for
+      ++ any \spad{a}, \spad{b} in M.
+      ++ This implies that \spad{g(n a) = n g(a)} for
+      ++ any \spad{a} in M and integer \spad{n > 0}.
+    evaluateInverse: ($, M -> M) -> $
+	++ evaluateInverse(x,f) \undocumented
+    "**": (OP, Integer) -> $
+	++ op**n \undocumented
+    "**": ($, Integer) -> $
+	++ op**n \undocumented
+    opeval  : (OP, M) -> M
+      ++ opeval should be local but conditional
+    makeop   : (R, FG) -> $
+      ++ makeop should be local but conditional
+
+  Implementation ==> FAB add
+    import NoneFunctions1($)
+    import BasicOperatorFunctions1(M)
+
+    Rep := FAB
+
+    inv      : TERM -> $
+    termeval : (TERM, M) -> M
+    rmeval   : (RM, M) -> M
+    monomeval: (FG, M) -> M
+    opInvEval: (OP, M) -> M
+    mkop     : (R, FG) -> $
+    termprod0: (Integer, TERM, TERM) -> $
+    termprod : (Integer, TERM, TERM) -> TERM
+    termcopy : TERM -> TERM
+    trm2O    : (Integer, TERM) -> O
+    term2O   : TERM -> O
+    rm2O     : (R, FG) -> O
+    nocopy   : OP -> $
+
+    1                   == makeop(1, 1)
+    coerce(n:Integer):$ == n::R::$
+    coerce(r:R):$       == (zero? r => 0; makeop(r, 1))
+    coerce(op:OP):$     == nocopy copy op
+    nocopy(op:OP):$     == makeop(1, op::FG)
+    elt(x:$, r:M)       == +/[t.exp * termeval(t.gen, r) for t in terms x]
+    rmeval(t, r)        == t.coef * monomeval(t.monom, r)
+    termcopy t          == [[rm.coef, rm.monom] for rm in t]
+    characteristic()    == characteristic()$R
+    mkop(r, fg)         == [[r, fg]$RM]$TERM :: $
+    evaluate(f, g)   == nocopy setProperty(retract(f)@OP,OPEVAL,g pretend None)
+
+    if R has OrderedSet then
+      makeop(r, fg) == (r >= 0 => mkop(r, fg); - mkop(-r, fg))
+    else makeop(r, fg) == mkop(r, fg)
+
+    inv(t:TERM):$ ==
+      empty? t => 1
+      c := first(t).coef
+      m := first(t).monom
+      inv(rest t) * makeop(1, inv m) * (recip(c)::R::$)
+
+    x:$ ** i:Integer ==
+      i = 0 => 1
+      i > 0 => expt(x,i pretend PositiveInteger)$RepeatedSquaring($)
+      (inv(retract(x)@TERM)) ** (-i)
+
+    evaluateInverse(f, g) ==
+      nocopy setProperty(retract(f)@OP, INVEVAL, g pretend None)
+
+    coerce(x:$):O ==
+      zero? x => (0$R)::O
+      reduce(_+, [trm2O(t.exp, t.gen) for t in terms x])$List(O)
+
+    trm2O(c, t) ==
+--      one? c => term2O t
+      (c = 1) => term2O t
+      c = -1 => - term2O t
+      c::O * term2O t
+
+    term2O t ==
+      reduce(_*, [rm2O(rm.coef, rm.monom) for rm in t])$List(O)
+
+    rm2O(c, m) ==
+--      one? c => m::O
+      (c = 1) => m::O
+--      one? m => c::O
+      (m = 1) => c::O
+      c::O * m::O
+
+    x:$ * y:$ ==
+      +/[ +/[termprod0(t.exp * s.exp, t.gen, s.gen) for s in terms y]
+          for t in terms x]
+
+    termprod0(n, x, y) ==
+      n >= 0 => termprod(n, x, y)::$
+      - (termprod(-n, x, y)::$)
+
+    termprod(n, x, y) ==
+      lc := first(xx := termcopy x)
+      lc.coef := n * lc.coef
+      rm := last xx
+--      one?(first(y).coef) =>
+      ((first(y).coef) = 1) =>
+        rm.monom := rm.monom * first(y).monom
+        concat_!(xx, termcopy rest y)
+--      one?(rm.monom) =>
+      ((rm.monom) = 1) =>
+        rm.coef := rm.coef * first(y).coef
+        rm.monom := first(y).monom
+        concat_!(xx, termcopy rest y)
+      concat_!(xx, termcopy y)
+
+    if M has ExpressionSpace then
+      opeval(op, r) ==
+        (func := property(op, OPEVAL)) case "failed" => kernel(op, r)
+        ((func::None) pretend (M -> M)) r
+
+    else
+      opeval(op, r) ==
+        (func := property(op, OPEVAL)) case "failed" =>
+          error "eval: operator has no evaluation function"
+        ((func::None) pretend (M -> M)) r
+
+    opInvEval(op, r) ==
+      (func := property(op, INVEVAL)) case "failed" =>
+         error "eval: operator has no inverse evaluation function"
+      ((func::None) pretend (M -> M)) r
+
+    termeval(t, r)  ==
+      for rm in reverse t repeat r := rmeval(rm, r)
+      r
+
+    monomeval(m, r) ==
+      for rec in reverse_! factors m repeat
+        e := rec.exp
+        g := rec.gen
+        e > 0 =>
+          for i in 1..e repeat r := opeval(g, r)
+        e < 0 =>
+          for i in 1..(-e) repeat r := opInvEval(g, r)
+      r
+
+    recip x ==
+      (r := retractIfCan(x)@Union(R, "failed")) case "failed" => "failed"
+      (r1 := recip(r::R)) case "failed" => "failed"
+      r1::R::$
+
+    retractIfCan(x:$):Union(R, "failed") ==
+      (r:= retractIfCan(x)@Union(TERM,"failed")) case "failed" => "failed"
+      empty?(t := r::TERM) => 0$R
+      empty? rest t =>
+        rm := first t
+--        one?(rm.monom) => rm.coef
+        (rm.monom = 1) => rm.coef
+        "failed"
+      "failed"
+
+    retractIfCan(x:$):Union(OP, "failed") ==
+      (r:= retractIfCan(x)@Union(TERM,"failed")) case "failed" => "failed"
+      empty?(t := r::TERM) => "failed"
+      empty? rest t =>
+        rm := first t
+--        one?(rm.coef) => retractIfCan(rm.monom)
+        (rm.coef = 1) => retractIfCan(rm.monom)
+        "failed"
+      "failed"
+
+    if R has CommutativeRing then
+      termadj  : TERM -> $
+      rmadj    : RM -> $
+      monomadj : FG -> $
+      opadj    : OP -> $
+
+      r:R * x:$        == r::$ * x
+      x:$ * r:R        == x * (r::$)
+      adjoint x        == +/[t.exp * termadj(t.gen) for t in terms x]
+      rmadj t          == conjug(t.coef) * monomadj(t.monom)
+      adjoint(op, adj) == nocopy setProperty(retract(op)@OP, OPADJ, adj::None)
+
+      termadj t ==
+        ans:$ := 1
+        for rm in t repeat ans := rmadj(rm) * ans
+        ans
+
+      monomadj m ==
+        ans:$ := 1
+        for rec in factors m repeat ans := (opadj(rec.gen) ** rec.exp) * ans
+        ans
+
+      opadj op ==
+        (adj := property(op, OPADJ)) case "failed" =>
+           error "adjoint: operator does not have a defined adjoint"
+        (adj::None) pretend $
+
+      if R has conjugate:R -> R then conjug r == conjugate r else conjug r == r
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain MOEBIUS MoebiusTransform}
 \pagehead{MoebiusTransform}{MOEBIUS}
 \pagepic{ps/v103moebiustransform.ps}{MOEBIUS}{1.00}
@@ -38167,6 +39342,680 @@ MultivariatePolynomial(vl:List Symbol, R:Ring)
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Chapter N}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain NSMP NewSparseMultivariatePolynomial}
+Based on the {\bf PseudoRemainderSequence} package, the domain
+constructor {\bf NewSparseMulitvariatePolynomial} extends
+the constructor {\bf SparseMultivariatePolynomial}. It also provides
+some additional operations related to polynomial system solving
+by means of triangular sets.
+\pagehead{NewSparseMultivariatePolynomial}{NSMP}
+\pagepic{ps/v103newsparsemultivariatepolynomial.ps}{NSMP}{1.00}
+See also:\\
+\refto{NewSparseUnivariatePolynomial}{NSUP}
+<<domain NSMP NewSparseMultivariatePolynomial>>=
+)abbrev domain NSMP NewSparseMultivariatePolynomial
+++ Author: Marc Moreno Maza
+++ Date Created: 22/04/94
+++ Date Last Updated: 14/12/1998
+++ Basic Operations: 
+++ Related Domains:
+++ Also See:
+++ AMS Classifications:
+++ Keywords: 
+++ Examples:
+++ References:
+++ Description: A post-facto extension for \axiomType{SMP} in order
+++ to speed up operations related to pseudo-division and gcd.
+++ This domain is based on the \axiomType{NSUP} constructor which is 
+++ itself a post-facto extension of the \axiomType{SUP} constructor.
+++ Version: 2
+
+NewSparseMultivariatePolynomial(R,VarSet) : Exports == Implementation where
+  R:Ring
+  VarSet:OrderedSet
+  N ==> NonNegativeInteger
+  Z ==> Integer
+  SUP ==> NewSparseUnivariatePolynomial
+  SMPR ==> SparseMultivariatePolynomial(R, VarSet)
+  SUP2 ==> NewSparseUnivariatePolynomialFunctions2($,$)
+
+  Exports == Join(RecursivePolynomialCategory(R,IndexedExponents VarSet, VarSet),
+                  CoercibleTo(SMPR),RetractableTo(SMPR))
+
+  Implementation ==  SparseMultivariatePolynomial(R, VarSet) add
+
+     D := NewSparseUnivariatePolynomial($)
+     VPoly:=  Record(v:VarSet,ts:D)
+     Rep:= Union(R,VPoly)
+
+    --local function
+     PSimp: (D,VarSet) -> %
+
+     PSimp(up,mv) ==
+       if degree(up) = 0 then leadingCoefficient(up) else [mv,up]$VPoly
+
+     coerce (p:$):SMPR == 
+       p pretend SMPR
+
+     coerce (p:SMPR):$ == 
+       p pretend $
+
+     retractIfCan (p:$) : Union(SMPR,"failed") == 
+       (p pretend SMPR)::Union(SMPR,"failed")
+
+     mvar p == 
+       p case R => error" Error in mvar from NSMP : #1 has no variables."
+       p.v
+
+     mdeg p == 
+       p case R => 0$N
+       degree(p.ts)$D
+
+     init p == 
+       p case R => error" Error in init from NSMP : #1 has no variables."
+       leadingCoefficient(p.ts)$D
+
+     head p == 
+       p case R => p
+       ([p.v,leadingMonomial(p.ts)$D]$VPoly)::Rep
+
+     tail p == 
+       p case R => 0$$
+       red := reductum(p.ts)$D
+       ground?(red)$D => (ground(red)$D)::Rep
+       ([p.v,red]$VPoly)::Rep
+
+     iteratedInitials p == 
+       p case R => [] 
+       p := leadingCoefficient(p.ts)$D
+       cons(p,iteratedInitials(p)) 
+
+     localDeepestInitial (p : $) : $ == 
+       p case R => p 
+       localDeepestInitial leadingCoefficient(p.ts)$D 
+
+     deepestInitial p == 
+       p case R => error"Error in deepestInitial from NSMP : #1 has no variables."
+       localDeepestInitial leadingCoefficient(p.ts)$D  
+
+     mainMonomial p == 
+       zero? p => error"Error in mainMonomial from NSMP : the argument is zero"
+       p case R => 1$$ 
+       monomial(1$$,p.v,degree(p.ts)$D)
+
+     leastMonomial p == 
+       zero? p => error"Error in leastMonomial from NSMP : the argument is zero"
+       p case R => 1$$
+       monomial(1$$,p.v,minimumDegree(p.ts)$D)
+
+     mainCoefficients p == 
+       zero? p => error"Error in mainCoefficients from NSMP : the argument is zero"
+       p case R => [p]
+       coefficients(p.ts)$D
+
+     leadingCoefficient(p:$,x:VarSet):$ == 
+       (p case R) => p
+       p.v = x => leadingCoefficient(p.ts)$D
+       zero? (d := degree(p,x)) => p
+       coefficient(p,x,d)
+
+     localMonicModulo(a:$,b:$):$ ==
+       -- b is assumed to have initial 1
+       a case R => a
+       a.v < b.v => a 
+       mM: $
+       if a.v > b.v
+         then 
+           m : D := map(localMonicModulo(#1,b),a.ts)$SUP2
+         else
+           m : D := monicModulo(a.ts,b.ts)$D
+       if ground?(m)$D 
+          then 
+            mM := (ground(m)$D)::Rep 
+          else 
+            mM := ([a.v,m]$VPoly)::Rep
+       mM
+
+     monicModulo (a,b) == 
+       b case R => error"Error in monicModulo from NSMP : #2 is constant"
+       ib : $ := init(b)@$
+       not ground?(ib)$$ => 
+         error"Error in monicModulo from NSMP : #2 is not monic"
+       mM : $
+--       if not one?(ib)$$
+       if not ((ib) = 1)$$
+         then
+           r : R := ground(ib)$$
+           rec : Union(R,"failed"):= recip(r)$R
+           (rec case "failed") =>
+             error"Error in monicModulo from NSMP : #2 is not monic"
+           a case R => a
+           a := (rec::R) * a
+           b := (rec::R) * b
+           mM := ib * localMonicModulo (a,b)
+         else
+           mM := localMonicModulo (a,b)
+       mM
+
+     prem(a:$, b:$): $ == 
+       -- with pseudoRemainder$NSUP
+       b case R =>
+         error "in prem$NSMP: ground? #2"
+       db: N := degree(b.ts)$D
+       lcb: $ := leadingCoefficient(b.ts)$D
+       test: Z := degree(a,b.v)::Z - db
+       delta: Z := max(test + 1$Z, 0$Z)
+       (a case R) or (a.v < b.v) => lcb ** (delta::N) * a
+       a.v = b.v =>
+         r: D := pseudoRemainder(a.ts,b.ts)$D
+         ground?(r) => return (ground(r)$D)::Rep 
+         ([a.v,r]$VPoly)::Rep
+       while not zero?(a) and not negative?(test) repeat 
+         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
+         a := lcb * a - term * b
+         delta := delta - 1$Z 
+         test := degree(a,b.v)::Z - db
+       lcb ** (delta::N) * a
+
+     pquo (a:$, b:$)  : $ == 
+       cPS := lazyPseudoDivide (a,b)
+       c := (cPS.coef) ** (cPS.gap)
+       c * cPS.quotient
+
+     pseudoDivide(a:$, b:$): Record (quotient : $, remainder : $) ==
+       -- from RPOLCAT
+       cPS := lazyPseudoDivide(a,b)
+       c := (cPS.coef) ** (cPS.gap)
+       [c * cPS.quotient, c * cPS.remainder]
+
+     lazyPrem(a:$, b:$): $ == 
+       -- with lazyPseudoRemainder$NSUP
+       -- Uses leadingCoefficient: ($, V) -> $
+       b case R =>
+         error "in lazyPrem$NSMP: ground? #2"
+       (a case R) or (a.v < b.v) =>  a
+       a.v = b.v => PSimp(lazyPseudoRemainder(a.ts,b.ts)$D,a.v)
+       db: N := degree(b.ts)$D
+       lcb: $ := leadingCoefficient(b.ts)$D
+       test: Z := degree(a,b.v)::Z - db
+       while not zero?(a) and not negative?(test) repeat 
+         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
+         a := lcb * a - term * b
+         test := degree(a,b.v)::Z - db
+       a
+
+     lazyPquo (a:$, b:$) : $ ==
+       -- with lazyPseudoQuotient$NSUP
+       b case R =>
+         error " in lazyPquo$NSMP: #2 is conctant"
+       (a case R) or (a.v < b.v) => 0
+       a.v = b.v => PSimp(lazyPseudoQuotient(a.ts,b.ts)$D,a.v)
+       db: N := degree(b.ts)$D
+       lcb: $ := leadingCoefficient(b.ts)$D
+       test: Z := degree(a,b.v)::Z - db
+       q := 0$$
+       test: Z := degree(a,b.v)::Z - db
+       while not zero?(a) and not negative?(test) repeat 
+         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
+         a := lcb * a - term * b
+         q := lcb * q + term
+         test := degree(a,b.v)::Z - db
+       q
+
+     lazyPseudoDivide(a:$, b:$): Record(coef:$, gap: N,quotient:$, remainder:$) == 
+       -- with lazyPseudoDivide$NSUP
+       b case R =>
+         error " in lazyPseudoDivide$NSMP: #2 is conctant"
+       (a case R) or (a.v < b.v) => [1$$,0$N,0$$,a]
+       a.v = b.v =>
+         cgqr := lazyPseudoDivide(a.ts,b.ts)
+         [cgqr.coef, cgqr.gap, PSimp(cgqr.quotient,a.v), PSimp(cgqr.remainder,a.v)]
+       db: N := degree(b.ts)$D
+       lcb: $ := leadingCoefficient(b.ts)$D
+       test: Z := degree(a,b.v)::Z - db
+       q := 0$$
+       delta: Z := max(test + 1$Z, 0$Z) 
+       while not zero?(a) and not negative?(test) repeat 
+         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
+         a := lcb * a - term * b
+         q := lcb * q + term
+         delta := delta - 1$Z 
+         test := degree(a,b.v)::Z - db
+       [lcb, (delta::N), q, a]
+
+     lazyResidueClass(a:$, b:$): Record(polnum:$, polden:$, power:N) == 
+       -- with lazyResidueClass$NSUP
+       b case R =>
+         error " in lazyResidueClass$NSMP: #2 is conctant"
+       lcb: $ := leadingCoefficient(b.ts)$D
+       (a case R) or (a.v < b.v) => [a,lcb,0]
+       a.v = b.v =>
+         lrc := lazyResidueClass(a.ts,b.ts)$D
+         [PSimp(lrc.polnum,a.v), lrc.polden, lrc.power]
+       db: N := degree(b.ts)$D
+       test: Z := degree(a,b.v)::Z - db
+       pow: N := 0
+       while not zero?(a) and not negative?(test) repeat 
+         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
+         a := lcb * a - term * b
+         pow := pow + 1
+         test := degree(a,b.v)::Z - db
+       [a, lcb, pow]
+
+     if R has IntegralDomain
+     then
+
+       packD := PseudoRemainderSequence($,D)
+
+       exactQuo(x:$, y:$):$ == 
+         ex: Union($,"failed") := x exquo$$ y
+         (ex case $) => ex::$
+         error "in exactQuotient$NSMP: bad args"
+
+       LazardQuotient(x:$, y:$, n: N):$ == 
+         zero?(n) => error("LazardQuotient$NSMP : n = 0")
+--         one?(n) => x
+         (n = 1) => x
+         a: N := 1
+         while n >= (b := 2*a) repeat a := b
+         c: $ := x
+         n := (n - a)::N
+         repeat       
+--           one?(a) => return c
+           (a = 1) => return c
+           a := a quo 2
+           c := exactQuo(c*c,y)
+           if n >= a then ( c := exactQuo(c*x,y) ; n := (n - a)::N )
+
+       LazardQuotient2(p:$, a:$, b:$, n: N) ==
+         zero?(n) => error " in LazardQuotient2$NSMP: bad #4"
+--         one?(n) => p
+         (n = 1) => p
+         c: $  := LazardQuotient(a,b,(n-1)::N)
+         exactQuo(c*p,b)
+
+       next_subResultant2(p:$, q:$, z:$, s:$) ==
+         PSimp(next_sousResultant2(p.ts,q.ts,z.ts,s)$packD,p.v)
+
+       subResultantGcd(a:$, b:$): $ ==
+         (a case R) or (b case R) => 
+           error "subResultantGcd$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "subResultantGcd$NSMP: mvar(#1) ~= mvar(#2)"
+         PSimp(subResultantGcd(a.ts,b.ts),a.v)
+
+       halfExtendedSubResultantGcd1(a:$,b:$): Record (gcd: $, coef1: $) ==
+         (a case R) or (b case R) => 
+           error "halfExtendedSubResultantGcd1$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "halfExtendedSubResultantGcd1$NSMP: mvar(#1) ~= mvar(#2)"
+         hesrg := halfExtendedSubResultantGcd1(a.ts,b.ts)$D
+         [PSimp(hesrg.gcd,a.v), PSimp(hesrg.coef1,a.v)]
+
+       halfExtendedSubResultantGcd2(a:$,b:$): Record (gcd: $, coef2: $) ==
+         (a case R) or (b case R) => 
+           error "halfExtendedSubResultantGcd2$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "halfExtendedSubResultantGcd2$NSMP: mvar(#1) ~= mvar(#2)"
+         hesrg := halfExtendedSubResultantGcd2(a.ts,b.ts)$D
+         [PSimp(hesrg.gcd,a.v), PSimp(hesrg.coef2,a.v)]
+
+       extendedSubResultantGcd(a:$,b:$): Record (gcd: $, coef1: $, coef2: $) ==
+         (a case R) or (b case R) => 
+           error "extendedSubResultantGcd$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "extendedSubResultantGcd$NSMP: mvar(#1) ~= mvar(#2)"
+         esrg := extendedSubResultantGcd(a.ts,b.ts)$D
+         [PSimp(esrg.gcd,a.v),PSimp(esrg.coef1,a.v),PSimp(esrg.coef2,a.v)]  
+
+       resultant(a:$, b:$): $ ==
+         (a case R) or (b case R) => 
+           error "resultant$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "resultant$NSMP: mvar(#1) ~= mvar(#2)"
+         resultant(a.ts,b.ts)$D
+
+       subResultantChain(a:$, b:$): List $ ==
+         (a case R) or (b case R) => 
+           error "subResultantChain$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "subResultantChain$NSMP: mvar(#1) ~= mvar(#2)"
+         [PSimp(up,a.v) for up in subResultantsChain(a.ts,b.ts)]
+
+       lastSubResultant(a:$, b:$): $ ==
+         (a case R) or (b case R) => 
+           error "lastSubResultant$NSMP: one arg is constant"
+         a.v ~= b.v => 
+           error "lastSubResultant$NSMP: mvar(#1) ~= mvar(#2)"
+         PSimp(lastSubResultant(a.ts,b.ts),a.v)
+
+       if R has EuclideanDomain
+       then
+
+         exactQuotient (a:$,b:R) ==
+--           one? b => a
+           (b = 1) => a
+           a case R => (a::R quo$R b)::$
+           ([a.v, map(exactQuotient(#1,b),a.ts)$SUP2]$VPoly)::Rep
+
+         exactQuotient! (a:$,b:R) ==
+--           one? b => a
+           (b = 1) => a
+           a case R => (a::R quo$R b)::$
+           a.ts := map(exactQuotient!(#1,b),a.ts)$SUP2
+           a
+
+       else
+
+         exactQuotient (a:$,b:R) ==
+--           one? b => a
+           (b = 1) => a
+           a case R => ((a::R exquo$R b)::R)::$
+           ([a.v, map(exactQuotient(#1,b),a.ts)$SUP2]$VPoly)::Rep
+
+         exactQuotient! (a:$,b:R) == 
+--           one? b => a
+           (b = 1) => a
+           a case R => ((a::R exquo$R b)::R)::$
+           a.ts := map(exactQuotient!(#1,b),a.ts)$SUP2
+           a
+
+     if R has GcdDomain
+     then
+
+       localGcd(r:R,p:$):R ==
+         p case R => gcd(r,p::R)$R
+         gcd(r,content(p))$R         
+
+       gcd(r:R,p:$):R ==
+--         one? r => r
+         (r = 1) => r
+         zero? p => r
+         localGcd(r,p)
+
+       content p ==
+         p case R => p
+         up : D := p.ts
+         r := 0$R
+--         while (not zero? up) and (not one? r) repeat
+         while (not zero? up) and (not (r = 1)) repeat
+           r := localGcd(r,leadingCoefficient(up))
+           up := reductum up
+         r
+
+       primitivePart! p ==
+         zero? p => p
+         p case R => 1$$
+         cp := content(p)
+         p.ts := unitCanonical(map(exactQuotient!(#1,cp),p.ts)$SUP2)$D
+         p
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain NSUP NewSparseUnivariatePolynomial}
+Based on the {\bf PseudoRemainderSequence} package, the domain
+constructor {\bf NewSparseUnivariatePolynomial} extends the
+constructur {\bf SparseUnivariatePolynomial}. 
+\pagehead{NewSparseUnivariatePolynomial}{NSUP}
+\pagepic{ps/v103newsparseunivariatepolynomial.ps}{NSUP}{1.00}
+See also:\\
+\refto{NewSparseMultivariatePolynomial}{NSMP}
+<<domain NSUP NewSparseUnivariatePolynomial>>=
+)abbrev domain NSUP NewSparseUnivariatePolynomial
+++ Author: Marc Moreno Maza
+++ Date Created: 23/07/98
+++ Date Last Updated: 14/12/98
+++ Basic Operations: 
+++ Related Domains:
+++ Also See:
+++ AMS Classifications:
+++ Keywords: 
+++ Examples:
+++ References: 
+++ Description: A post-facto extension for \axiomType{SUP} in order
+++ to speed up operations related to pseudo-division and gcd for
+++ both \axiomType{SUP} and, consequently, \axiomType{NSMP}.
+
+NewSparseUnivariatePolynomial(R): Exports == Implementation where
+
+  R:Ring
+  NNI ==> NonNegativeInteger
+  SUPR ==> SparseUnivariatePolynomial R
+
+  Exports == Join(UnivariatePolynomialCategory(R), 
+   CoercibleTo(SUPR),RetractableTo(SUPR)) with
+     fmecg : (%,NNI,R,%) -> %
+        ++ \axiom{fmecg(p1,e,r,p2)} returns \axiom{p1 - r * X**e * p2}
+        ++ where \axiom{X} is \axiom{monomial(1,1)}
+     monicModulo : ($, $) -> $ 
+        ++ \axiom{monicModulo(a,b)} returns \axiom{r} such that \axiom{r} is 
+        ++ reduced w.r.t. \axiom{b} and \axiom{b} divides \axiom{a -r}
+        ++ where \axiom{b} is monic.
+     lazyResidueClass: ($,$) -> Record(polnum:$, polden:R, power:NNI)
+        ++ \axiom{lazyResidueClass(a,b)} returns \axiom{[r,c,n]} such that 
+        ++ \axiom{r} is reduced w.r.t. \axiom{b} and \axiom{b} divides 
+        ++ \axiom{c^n * a - r} where \axiom{c} is \axiom{leadingCoefficient(b)} 
+        ++ and \axiom{n} is as small as possible with the previous properties.
+     lazyPseudoRemainder: ($,$) -> $
+        ++ \axiom{lazyPseudoRemainder(a,b)} returns \axiom{r} if \axiom{lazyResidueClass(a,b)}
+        ++ returns \axiom{[r,c,n]}. This lazy pseudo-remainder is computed by 
+        ++ means of the \axiomOpFrom{fmecg}{NewSparseUnivariatePolynomial} operation.
+     lazyPseudoDivide: ($,$) -> Record(coef:R, gap:NNI, quotient:$, remainder: $)
+        ++ \axiom{lazyPseudoDivide(a,b)} returns \axiom{[c,g,q,r]} such that 
+        ++ \axiom{c^n * a = q*b +r} and \axiom{lazyResidueClass(a,b)} returns \axiom{[r,c,n]}
+        ++ where \axiom{n + g = max(0, degree(b) - degree(a) + 1)}.
+     lazyPseudoQuotient: ($,$) -> $
+        ++ \axiom{lazyPseudoQuotient(a,b)} returns \axiom{q} if \axiom{lazyPseudoDivide(a,b)}
+        ++ returns \axiom{[c,g,q,r]} 
+     if R has IntegralDomain
+     then 
+       subResultantsChain: ($, $) -> List $
+         ++ \axiom{subResultantsChain(a,b)} returns the list of the non-zero
+         ++ sub-resultants of \axiom{a} and \axiom{b} sorted by increasing 
+         ++ degree.
+       lastSubResultant: ($, $) -> $
+         ++ \axiom{lastSubResultant(a,b)} returns \axiom{resultant(a,b)}
+         ++ if \axiom{a} and \axiom{b} has no non-trivial gcd in \axiom{R^(-1) P}
+         ++ otherwise the non-zero sub-resultant with smallest index.
+       extendedSubResultantGcd: ($, $) -> Record(gcd: $, coef1: $, coef2: $)
+         ++ \axiom{extendedSubResultantGcd(a,b)} returns \axiom{[g,ca, cb]} such
+         ++ that \axiom{g} is a gcd of \axiom{a} and \axiom{b} in \axiom{R^(-1) P}
+         ++ and \axiom{g = ca * a + cb * b}
+       halfExtendedSubResultantGcd1: ($, $) -> Record(gcd: $, coef1: $)
+         ++ \axiom{halfExtendedSubResultantGcd1(a,b)} returns \axiom{[g,ca]} such that
+         ++ \axiom{extendedSubResultantGcd(a,b)} returns \axiom{[g,ca, cb]}
+       halfExtendedSubResultantGcd2: ($, $) -> Record(gcd: $, coef2: $)
+         ++ \axiom{halfExtendedSubResultantGcd2(a,b)} returns \axiom{[g,cb]} such that
+         ++ \axiom{extendedSubResultantGcd(a,b)} returns \axiom{[g,ca, cb]}
+       extendedResultant: ($, $) -> Record(resultant: R, coef1: $, coef2: $)
+         ++ \axiom{extendedResultant(a,b)} returns  \axiom{[r,ca,cb]} such that 
+         ++ \axiom{r} is the resultant of \axiom{a} and \axiom{b} and
+         ++ \axiom{r = ca * a + cb * b}
+       halfExtendedResultant1: ($, $) -> Record(resultant: R, coef1: $)
+         ++ \axiom{halfExtendedResultant1(a,b)} returns \axiom{[r,ca]} such that 
+         ++ \axiom{extendedResultant(a,b)}  returns \axiom{[r,ca, cb]} 
+       halfExtendedResultant2: ($, $) -> Record(resultant: R, coef2: $)
+         ++ \axiom{halfExtendedResultant2(a,b)} returns \axiom{[r,ca]} such that 
+         ++ \axiom{extendedResultant(a,b)} returns \axiom{[r,ca, cb]} 
+
+  Implementation == SparseUnivariatePolynomial(R) add
+   
+     Term == Record(k:NonNegativeInteger,c:R)
+     Rep ==> List Term
+
+     rep(s:$):Rep == s pretend Rep
+     per(l:Rep):$ == l pretend $
+
+     coerce (p:$):SUPR == 
+       p pretend SUPR
+
+     coerce (p:SUPR):$ == 
+       p pretend $
+
+     retractIfCan (p:$) : Union(SUPR,"failed") == 
+       (p pretend SUPR)::Union(SUPR,"failed")
+
+     monicModulo(x,y) ==
+		zero? y => 
+		   error "in monicModulo$NSUP: division by 0"
+		ground? y =>
+		   error "in monicModulo$NSUP: ground? #2"
+                yy := rep y
+--                not one? (yy.first.c) => 
+                not ((yy.first.c) = 1) => 
+		   error "in monicModulo$NSUP: not monic #2"
+                xx := rep x; empty? xx => x
+                e := yy.first.k; y := per(yy.rest)                
+                -- while (not empty? xx) repeat
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  xx:= rep fmecg(per rest(xx), u, xx.first.c, y)
+                  if empty? xx then break
+                per xx
+
+     lazyResidueClass(x,y) ==
+		zero? y => 
+		   error "in lazyResidueClass$NSUP: division by 0"
+		ground? y =>
+		   error "in lazyResidueClass$NSUP: ground? #2"
+                yy := rep y; co := yy.first.c; xx: Rep := rep x
+                empty? xx => [x, co, 0]
+                pow: NNI := 0; e := yy.first.k; y := per(yy.rest); 
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  xx:= rep fmecg(co * per rest(xx), u, xx.first.c, y)
+                  pow := pow + 1
+                  if empty? xx then break
+                [per xx, co, pow]
+
+     lazyPseudoRemainder(x,y) ==
+		zero? y => 
+		   error "in lazyPseudoRemainder$NSUP: division by 0"
+		ground? y =>
+		   error "in lazyPseudoRemainder$NSUP: ground? #2"
+		ground? x => x
+                yy := rep y; co := yy.first.c
+--                one? co => monicModulo(x,y)
+                (co = 1) => monicModulo(x,y)
+                (co = -1) => - monicModulo(-x,-y)
+                xx:= rep x; e := yy.first.k; y := per(yy.rest)
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  xx:= rep fmecg(co * per rest(xx), u, xx.first.c, y)
+                  if empty? xx then break
+                per xx
+
+     lazyPseudoDivide(x,y) ==
+		zero? y => 
+		   error "in lazyPseudoDivide$NSUP: division by 0"
+		ground? y =>
+		   error "in lazyPseudoDivide$NSUP: ground? #2"
+                yy := rep y; e := yy.first.k; 
+                xx: Rep := rep x; co := yy.first.c
+		(empty? xx) or (xx.first.k < e) => [co,0,0,x]
+                pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1
+                qq: Rep := []; y := per(yy.rest)
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
+                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
+                  pow := subtractIfCan(pow,1)::NNI
+                  if empty? xx then break
+                [co, pow, per reverse qq, per xx]
+
+     lazyPseudoQuotient(x,y) ==
+		zero? y => 
+		   error "in lazyPseudoQuotient$NSUP: division by 0"
+		ground? y =>
+		   error "in lazyPseudoQuotient$NSUP: ground? #2"
+                yy := rep y; e := yy.first.k; xx: Rep := rep x
+		(empty? xx) or (xx.first.k < e) => 0
+                qq: Rep := []; co := yy.first.c; y := per(yy.rest)
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
+                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
+                  if empty? xx then break
+                per reverse qq
+
+     if R has IntegralDomain
+     then 
+       pack ==> PseudoRemainderSequence(R, %)
+
+       subResultantGcd(p1,p2) == subResultantGcd(p1,p2)$pack
+
+       subResultantsChain(p1,p2) == chainSubResultants(p1,p2)$pack
+
+       lastSubResultant(p1,p2) == lastSubResultant(p1,p2)$pack
+
+       resultant(p1,p2) == resultant(p1,p2)$pack
+
+       extendedResultant(p1,p2) == 
+          re: Record(coef1: $, coef2: $, resultant: R) := resultantEuclidean(p1,p2)$pack
+          [re.resultant, re.coef1, re.coef2]
+
+       halfExtendedResultant1(p1:$, p2: $): Record(resultant: R, coef1: $) ==
+          re: Record(coef1: $, resultant: R) := semiResultantEuclidean1(p1, p2)$pack
+          [re.resultant, re.coef1]
+
+       halfExtendedResultant2(p1:$, p2: $): Record(resultant: R, coef2: $) ==
+          re: Record(coef2: $, resultant: R) := semiResultantEuclidean2(p1, p2)$pack
+          [re.resultant, re.coef2]
+
+       extendedSubResultantGcd(p1,p2) == 
+          re: Record(coef1: $, coef2: $, gcd: $) := subResultantGcdEuclidean(p1,p2)$pack
+          [re.gcd, re.coef1, re.coef2]
+
+       halfExtendedSubResultantGcd1(p1:$, p2: $): Record(gcd: $, coef1: $) ==
+          re: Record(coef1: $, gcd: $) := semiSubResultantGcdEuclidean1(p1, p2)$pack
+          [re.gcd, re.coef1]
+
+       halfExtendedSubResultantGcd2(p1:$, p2: $): Record(gcd: $, coef2: $) ==
+          re: Record(coef2: $, gcd: $) := semiSubResultantGcdEuclidean2(p1, p2)$pack
+          [re.gcd, re.coef2]
+
+       pseudoDivide(x,y) ==
+		zero? y => 
+		   error "in pseudoDivide$NSUP: division by 0"
+		ground? y =>
+		   error "in pseudoDivide$NSUP: ground? #2"
+                yy := rep y; e := yy.first.k
+                xx: Rep := rep x; co := yy.first.c
+		(empty? xx) or (xx.first.k < e) => [co,0,x]
+                pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1
+                qq: Rep := []; y := per(yy.rest)
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
+                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
+                  pow := subtractIfCan(pow,1)::NNI
+                  if empty? xx then break
+                zero? pow => [co, per reverse qq, per xx]
+                default: R := co ** pow
+                q := default * (per reverse qq)
+                x := default * (per xx)
+                [co, q, x]
+
+       pseudoQuotient(x,y) ==
+		zero? y => 
+		   error "in pseudoDivide$NSUP: division by 0"
+		ground? y =>
+		   error "in pseudoDivide$NSUP: ground? #2"
+                yy := rep y; e := yy.first.k; xx: Rep := rep x
+		(empty? xx) or (xx.first.k < e) => 0
+                pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1
+                qq: Rep := []; co := yy.first.c; y := per(yy.rest)
+                repeat
+                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
+                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
+                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
+                  pow := subtractIfCan(pow,1)::NNI
+                  if empty? xx then break
+                zero? pow => per reverse qq
+                (co ** pow) * (per reverse qq)
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain NONE None}
 <<None.input>>=
 -- any.spad.pamphlet None.input
@@ -38566,6 +40415,355 @@ NumericalPDEProblem():SetCategory with
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Chapter O}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OCT Octonion}
+The octonions have the following multiplication table:
+$$
+\begin{array}{|r|r|r|r|r|r|r|r|}
+\hline
+1 &   i &   j &   k &   E &   I &   J &   K\\
+\hline
+i & - 1 &   k & - j &   I & - E & - K &   J\\
+\hline
+j & - k & - 1 &   i &   J &   K & - E & - I\\
+\hline
+k &   j & - i & - 1 &   K & - J &   I & - E\\
+\hline
+E & - I & - J & - K & - 1 &   i &   j &   k\\
+\hline
+I &   E & - K &   J & - i & - 1 & - k &   j\\
+\hline
+J &   K &   E & - I & - j &   k & - 1 & - i\\
+\hline
+K & - J &   I &   E & - k & - j &   i & - 1\\
+\hline
+\end{array}
+$$
+
+There are 3 different kinds of associativity. An algebra is
+\begin{itemize}
+\item {\bf power-associative} 
+if the subalgebra generated by any one element is associative.
+That is, given any element $e$ then $e*(e*e) = (e*e)*e$.
+\item {\bf alternative} 
+if the subalgebra generated by any two elements is associative
+That is, given any two elements, $a$ and $b$ then 
+$a*(a*b) = (a*a)*b$ and 
+$a*(b*a) = (a*b)*a$ and
+$b*(a*a) = (b*a)*a$.
+\item {\bf associative}
+if the subalgebra generated by any three elements is associative.
+That is, given any three elements $a$, $b$, and $c$ then
+$a*(b*c) = (a*b)*c$. 
+\end{itemize}
+The Octonions are power-associative and alternative but not
+associative, since $I*(J*K) \ne (I*J)*K$.
+
+\includegraphics{ps/v103octoniongraph.eps}
+<<Octonion.input>>=
+-- oct.spad.pamphlet Octonion.input
+)spool Octonion.output
+)set message test on
+)set message auto off
+)clear all
+--S 1 of 15
+oci1 := octon(1,2,3,4,5,6,7,8)
+--R 
+--R
+--R   (1)  1 + 2i + 3j + 4k + 5E + 6I + 7J + 8K
+--R                                                       Type: Octonion Integer
+--E 1
+
+--S 2 of 15
+oci2 := octon(7,2,3,-4,5,6,-7,0)
+--R 
+--R
+--R   (2)  7 + 2i + 3j - 4k + 5E + 6I - 7J
+--R                                                       Type: Octonion Integer
+--E 2
+
+--S 3 of 15
+oci3 := octon(quatern(-7,-12,3,-10), quatern(5,6,9,0))
+--R 
+--R
+--R   (3)  - 7 - 12i + 3j - 10k + 5E + 6I + 9J
+--R                                                       Type: Octonion Integer
+--E 3
+
+--S 4 of 15
+(oci1 * oci2) * oci3 - oci1 * (oci2 * oci3)
+--R 
+--R
+--R   (4)  2696i - 2928j - 4072k + 16E - 1192I + 832J + 2616K
+--R                                                       Type: Octonion Integer
+--E 4
+
+--S 5 of 15
+[real oci1, imagi oci1, imagj oci1, imagk oci1, _
+ imagE oci1, imagI oci1, imagJ oci1, imagK oci1]
+--R 
+--R
+--R   (5)  [1,2,3,4,5,6,7,8]
+--R                                                   Type: List PositiveInteger
+--E 5
+
+--S 6 of 15
+q : Quaternion Polynomial Integer := quatern(q1, qi, qj, qk)
+--R 
+--R
+--R   (6)  q1 + qi i + qj j + qk k
+--R                                          Type: Quaternion Polynomial Integer
+--E 6
+
+--S 7 of 15
+E : Octonion Polynomial Integer:= octon(0,0,0,0,1,0,0,0)
+--R 
+--R
+--R   (7)  E
+--R                                            Type: Octonion Polynomial Integer
+--E 7
+
+--S 8 of 15
+q * E
+--R 
+--R
+--R   (8)  q1 E + qi I + qj J + qk K
+--R                                            Type: Octonion Polynomial Integer
+--E 8
+
+--S 9 of 15
+E * q
+--R 
+--R
+--R   (9)  q1 E - qi I - qj J - qk K
+--R                                            Type: Octonion Polynomial Integer
+--E 9
+
+--S 10 of 15
+q * 1$(Octonion Polynomial Integer)
+--R 
+--R
+--R   (10)  q1 + qi i + qj j + qk k
+--R                                            Type: Octonion Polynomial Integer
+--E 10
+
+--S 11 of 15
+1$(Octonion Polynomial Integer) * q
+--R 
+--R
+--R   (11)  q1 + qi i + qj j + qk k
+--R                                            Type: Octonion Polynomial Integer
+--E 11
+
+--S 12 of 15
+o : Octonion Polynomial Integer := octon(o1, oi, oj, ok, oE, oI, oJ, oK)
+--R 
+--R
+--R   (12)  o1 + oi i + oj j + ok k + oE E + oI I + oJ J + oK K
+--R                                            Type: Octonion Polynomial Integer
+--E 12
+
+--S 13 of 15
+norm o
+--R 
+--R
+--R           2     2     2     2     2     2     2     2
+--R   (13)  ok  + oj  + oi  + oK  + oJ  + oI  + oE  + o1
+--R                                                     Type: Polynomial Integer
+--E 13
+
+--S 14 of 15
+p : Octonion Polynomial Integer := octon(p1, pi, pj, pk, pE, pI, pJ, pK)
+--R 
+--R
+--R   (14)  p1 + pi i + pj j + pk k + pE E + pI I + pJ J + pK K
+--R                                            Type: Octonion Polynomial Integer
+--E 14
+
+--S 15 of 15
+norm(o*p)-norm(p)*norm(o)
+--R 
+--R
+--R   (15)  0
+--R                                                     Type: Polynomial Integer
+--E 15
+)spool
+)lisp (bye)
+@
+<<Octonion.help>>=
+====================================================================
+Octonion examples
+====================================================================
+
+The Octonions, also called the Cayley-Dixon algebra, defined over a
+commutative ring are an eight-dimensional non-associative algebra.
+Their construction from quaternions is similar to the construction
+of quaternions from complex numbers.
+
+As Octonion creates an eight-dimensional algebra, you have to give
+eight components to construct an octonion.
+
+  oci1 := octon(1,2,3,4,5,6,7,8)
+    1 + 2i + 3j + 4k + 5E + 6I + 7J + 8K
+                              Type: Octonion Integer
+
+  oci2 := octon(7,2,3,-4,5,6,-7,0)
+    7 + 2i + 3j - 4k + 5E + 6I - 7J
+                              Type: Octonion Integer
+
+Or you can use two quaternions to create an octonion.
+
+  oci3 := octon(quatern(-7,-12,3,-10), quatern(5,6,9,0))
+    - 7 - 12i + 3j - 10k + 5E + 6I + 9J
+                              Type: Octonion Integer
+
+You can easily demonstrate the non-associativity of multiplication.
+
+  (oci1 * oci2) * oci3 - oci1 * (oci2 * oci3)
+    2696i - 2928j - 4072k + 16E - 1192I + 832J + 2616K
+                              Type: Octonion Integer
+
+As with the quaternions, we have a real part, the imaginary parts 
+i, j, k, and four additional imaginary parts E, I, J and K. These 
+parts correspond to the canonical basis (1,i,j,k,E,I,J,K).
+
+For each basis element there is a component operation to extract the
+coefficient of the basis element for a given octonion.
+
+  [real oci1, imagi oci1, imagj oci1, imagk oci1, _
+   imagE oci1, imagI oci1, imagJ oci1, imagK oci1]
+    [1,2,3,4,5,6,7,8]
+                              Type: List PositiveInteger
+
+A basis with respect to the quaternions is given by (1,E).  However,
+you might ask, what then are the commuting rules?  To answer this, we
+create some generic elements.
+
+We do this in Axiom by simply changing the ground ring from Integer to
+Polynomial Integer.
+
+  q : Quaternion Polynomial Integer := quatern(q1, qi, qj, qk)
+    q1 + qi i + qj j + qk k
+                             Type: Quaternion Polynomial Integer
+
+  E : Octonion Polynomial Integer:= octon(0,0,0,0,1,0,0,0)
+    E
+                             Type: Octonion Polynomial Integer
+
+Note that quaternions are automatically converted to octonions in the
+obvious way.
+
+  q * E
+    q1 E + qi I + qj J + qk K
+                             Type: Octonion Polynomial Integer
+
+  E * q
+    q1 E - qi I - qj J - qk K
+                             Type: Octonion Polynomial Integer
+
+  q * 1$(Octonion Polynomial Integer)
+    q1 + qi i + qj j + qk k
+                             Type: Octonion Polynomial Integer
+
+  1$(Octonion Polynomial Integer) * q
+    q1 + qi i + qj j + qk k
+                             Type: Octonion Polynomial Integer
+
+Finally, we check that the norm, defined as the sum of the squares of
+the coefficients, is a multiplicative map.
+
+  o : Octonion Polynomial Integer := octon(o1, oi, oj, ok, oE, oI, oJ, oK)
+    o1 + oi i + oj j + ok k + oE E + oI I + oJ J + oK K
+                             Type: Octonion Polynomial Integer
+
+  norm o
+      2     2     2     2     2     2     2     2
+    ok  + oj  + oi  + oK  + oJ  + oI  + oE  + o1
+                             Type: Polynomial Integer
+
+  p : Octonion Polynomial Integer := octon(p1, pi, pj, pk, pE, pI, pJ, pK)
+    p1 + pi i + pj j + pk k + pE E + pI I + pJ J + pK K
+                             Type: Octonion Polynomial Integer
+
+Since the result is 0, the norm is multiplicative.
+
+  norm(o*p)-norm(p)*norm(o)
+    0
+                             Type: Polynomial Integer
+
+See Also:
+o )help Quaternion
+o )show Octonion
+o $AXIOM/doc/src/algebra/oct.spad.dvi
+
+@
+\pagehead{Octonion}{OCT}
+\pagepic{ps/v103octonion.ps}{OCT}{1.00}
+<<domain OCT Octonion>>=
+)abbrev domain OCT Octonion
+++ Author: R. Wisbauer, J. Grabmeier
+++ Date Created: 05 September 1990
+++ Date Last Updated: 20 September 1990
+++ Basic Operations: _+,_*,octon,image,imagi,imagj,imagk,
+++  imagE,imagI,imagJ,imagK
+++ Related Constructors: Quaternion
+++ Also See: AlgebraGivenByStructuralConstants
+++ AMS Classifications:
+++ Keywords: octonion, non-associative algebra, Cayley-Dixon  
+++ References: e.g. I.L Kantor, A.S. Solodovnikov:
+++  Hypercomplex Numbers, Springer Verlag Heidelberg, 1989,
+++  ISBN 0-387-96980-2
+++ Description:
+++  Octonion implements octonions (Cayley-Dixon algebra) over a
+++  commutative ring, an eight-dimensional non-associative
+++  algebra, doubling the quaternions in the same way as doubling
+++  the complex numbers to get the quaternions 
+++  the main constructor function is {\em octon} which takes 8
+++  arguments: the real part, the i imaginary part, the j 
+++  imaginary part, the k imaginary part, (as with quaternions)
+++  and in addition the imaginary parts E, I, J, K.
+-- Examples: octonion.input
+--)boot $noSubsumption := true
+Octonion(R:CommutativeRing): export == impl where
+ 
+  QR ==> Quaternion R
+ 
+  export ==> Join(OctonionCategory R, FullyRetractableTo QR)  with
+    octon: (QR,QR) -> %
+      ++ octon(qe,qE) constructs an octonion from two quaternions
+      ++ using the relation {\em O = Q + QE}.
+  impl ==> add
+    Rep := Record(e: QR,E: QR)
+ 
+    0 == [0,0]
+    1 == [1,0]
+ 
+    a,b,c,d,f,g,h,i : R
+    p,q : QR
+    x,y : %
+ 
+    real  x == real (x.e)
+    imagi x == imagI (x.e)
+    imagj x == imagJ (x.e)
+    imagk x == imagK (x.e)
+    imagE x == real (x.E)
+    imagI x == imagI (x.E)
+    imagJ x == imagJ (x.E)
+    imagK x == imagK (x.E)
+    octon(a,b,c,d,f,g,h,i) == [quatern(a,b,c,d)$QR,quatern(f,g,h,i)$QR]
+    octon(p,q) == [p,q]
+    coerce(q) == [q,0$QR] 
+    retract(x):QR ==
+      not(zero? imagE x and zero? imagI x and zero? imagJ x and zero? imagK x)=>
+        error "Cannot retract octonion to quaternion."
+      quatern(real x, imagi x,imagj x, imagk x)$QR
+    retractIfCan(x):Union(QR,"failed") ==
+      not(zero? imagE x and zero? imagI x and zero? imagJ x and zero? imagK x)=>
+        "failed"
+      quatern(real x, imagi x,imagj x, imagk x)$QR
+    x * y == [x.e*y.e-(conjugate y.E)*x.E, y.E*x.e + x.E*(conjugate y.e)]
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain ODEIFTBL ODEIntensityFunctionsTable}
 \pagehead{ODEIntensityFunctionsTable}{ODEIFTBL}
 \pagepic{ps/v103odeintensityfunctionstable.ps}{ODEIFTBL}{1.00}
@@ -38960,6 +41158,782 @@ OnePointCompletion(R:SetCategory): Exports == Implementation where
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OMCONN OpenMathConnection}
+\pagehead{OpenMathConnection}{OMCONN}
+\pagepic{ps/v103openmathconnection.ps}{OMCONN}{1.00}
+See also:\\
+\refto{OpenMathEncoding}{OMENC}
+\refto{OpenMathDevice}{OMDEV}
+<<domain OMCONN OpenMathConnection>>=
+)abbrev domain OMCONN OpenMathConnection
+++ Author: Vilya Harvey
+++ Date Created:
+++ Date Last Updated:
+++ Basic Functions:
+++ Related Constructors:
+++ Also See:
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ Description: \spadtype{OpenMathConnection} provides low-level functions
+++ for handling connections to and from \spadtype{OpenMathDevice}s.
+
+
+OpenMathConnection(): with
+  OMmakeConn    : SingleInteger -> % ++ \spad{OMmakeConn}
+  OMcloseConn   : % -> Void ++ \spad{OMcloseConn}
+  OMconnInDevice: %-> OpenMathDevice ++ \spad{OMconnInDevice:}
+  OMconnOutDevice: %-> OpenMathDevice ++ \spad{OMconnOutDevice:}
+  OMconnectTCP  : (%, String, SingleInteger) -> Boolean ++ \spad{OMconnectTCP}
+  OMbindTCP     : (%, SingleInteger) -> Boolean ++ \spad{OMbindTCP}
+ == add
+  OMmakeConn(timeout: SingleInteger): % == OM_-MAKECONN(timeout)$Lisp
+  OMcloseConn(conn: %): Void == OM_-CLOSECONN(conn)$Lisp
+
+  OMconnInDevice(conn: %): OpenMathDevice ==
+    OM_-GETCONNINDEV(conn)$Lisp
+  OMconnOutDevice(conn: %): OpenMathDevice ==
+    OM_-GETCONNOUTDEV(conn)$Lisp
+
+  OMconnectTCP(conn: %, host: String, port: SingleInteger): Boolean ==
+    OM_-CONNECTTCP(conn, host, port)$Lisp
+  OMbindTCP(conn: %, port: SingleInteger): Boolean ==
+    OM_-BINDTCP(conn, port)$Lisp
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OMDEV OpenMathDevice}
+\pagehead{OpenMathDevice}{OMDEV}
+\pagepic{ps/v103openmathdevice.ps}{OMDEV}{1.00}
+See also:\\
+\refto{OpenMathEncoding}{OMENC}
+\refto{OpenMathConnection}{OMCONN}
+<<domain OMDEV OpenMathDevice>>=
+)abbrev domain OMDEV OpenMathDevice
+++ Author: Vilya Harvey
+++ Date Created:
+++ Date Last Updated:
+++ Basic Functions:
+++ Related Constructors:
+++ Also See:
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ Description: \spadtype{OpenMathDevice} provides support for reading
+++ and writing openMath objects to files, strings etc.  It also provides
+++ access to low-level operations from within the interpreter.
+
+
+OpenMathDevice(): with
+  OMopenFile    : (String, String, OpenMathEncoding) -> %
+  ++ OMopenFile(f,mode,enc) opens file \axiom{f} for reading or writing
+  ++ OpenMath objects (depending on \axiom{mode} which can be "r", "w"
+  ++ or "a" for read, write and append respectively), in the encoding
+  ++ \axiom{enc}.
+  OMopenString  : (String, OpenMathEncoding) -> %
+  ++ OMopenString(s,mode) opens the string \axiom{s} for reading or writing 
+  ++ OpenMath objects in encoding \axiom{enc}.
+  OMclose       : % -> Void
+  ++ OMclose(dev) closes \axiom{dev}, flushing output if necessary.
+  OMsetEncoding : (%, OpenMathEncoding) -> Void
+  ++ OMsetEncoding(dev,enc) sets the encoding used for reading or writing
+  ++ OpenMath objects to or from \axiom{dev} to \axiom{enc}.
+  OMputApp      : % -> Void
+  ++ OMputApp(dev) writes a begin application token to \axiom{dev}.
+  OMputAtp      : % -> Void
+  ++ OMputAtp(dev) writes a begin attribute pair token to \axiom{dev}.
+  OMputAttr     : % -> Void
+  ++ OMputAttr(dev) writes a begin attribute token to \axiom{dev}.
+  OMputBind     : % -> Void
+  ++ OMputBind(dev) writes a begin binder token to \axiom{dev}.
+  OMputBVar     : % -> Void
+  ++ OMputBVar(dev) writes a begin bound variable list token to \axiom{dev}.
+  OMputError    : % -> Void
+  ++ OMputError(dev) writes a begin error token to \axiom{dev}.
+  OMputObject   : % -> Void
+  ++ OMputObject(dev) writes a begin object token to \axiom{dev}.
+  OMputEndApp   : % -> Void
+  ++ OMputEndApp(dev) writes an end application token to \axiom{dev}.
+  OMputEndAtp   : % -> Void
+  ++ OMputEndAtp(dev) writes an end attribute pair token to \axiom{dev}.
+  OMputEndAttr  : % -> Void
+  ++ OMputEndAttr(dev) writes an end attribute token to \axiom{dev}.
+  OMputEndBind  : % -> Void
+  ++ OMputEndBind(dev) writes an end binder token to \axiom{dev}.
+  OMputEndBVar  : % -> Void
+  ++ OMputEndBVar(dev) writes an end bound variable list token to \axiom{dev}.
+  OMputEndError : % -> Void
+  ++ OMputEndError(dev) writes an end error token to \axiom{dev}.
+  OMputEndObject: % -> Void
+  ++ OMputEndObject(dev) writes an end object token to \axiom{dev}.
+  OMputInteger  : (%, Integer) -> Void
+  ++ OMputInteger(dev,i) writes the integer \axiom{i} to \axiom{dev}.
+  OMputFloat    : (%, DoubleFloat) -> Void
+  ++ OMputFloat(dev,i) writes the float \axiom{i} to \axiom{dev}.
+  OMputVariable : (%, Symbol) -> Void
+  ++ OMputVariable(dev,i) writes the variable \axiom{i} to \axiom{dev}.
+  OMputString   : (%, String) -> Void
+  ++ OMputString(dev,i) writes the string \axiom{i} to \axiom{dev}.
+  OMputSymbol   : (%, String, String) -> Void
+  ++ OMputSymbol(dev,cd,s) writes the symbol \axiom{s} from CD \axiom{cd}
+  ++ to \axiom{dev}.
+
+  OMgetApp      : % -> Void
+  ++ OMgetApp(dev) reads a begin application token from \axiom{dev}.
+  OMgetAtp      : % -> Void
+  ++ OMgetAtp(dev) reads a begin attribute pair token from \axiom{dev}.
+  OMgetAttr     : % -> Void
+  ++ OMgetAttr(dev) reads a begin attribute token from \axiom{dev}.
+  OMgetBind     : % -> Void
+  ++ OMgetBind(dev) reads a begin binder token from \axiom{dev}.
+  OMgetBVar     : % -> Void
+  ++ OMgetBVar(dev) reads a begin bound variable list token from \axiom{dev}.
+  OMgetError    : % -> Void
+  ++ OMgetError(dev) reads a begin error token from \axiom{dev}.
+  OMgetObject   : % -> Void
+  ++ OMgetObject(dev) reads a begin object token from \axiom{dev}.
+  OMgetEndApp   : % -> Void
+  ++ OMgetEndApp(dev) reads an end application token from \axiom{dev}.
+  OMgetEndAtp   : % -> Void
+  ++ OMgetEndAtp(dev) reads an end attribute pair token from \axiom{dev}.
+  OMgetEndAttr  : % -> Void
+  ++ OMgetEndAttr(dev) reads an end attribute token from \axiom{dev}.
+  OMgetEndBind  : % -> Void
+  ++ OMgetEndBind(dev) reads an end binder token from \axiom{dev}.
+  OMgetEndBVar  : % -> Void
+  ++ OMgetEndBVar(dev) reads an end bound variable list token from \axiom{dev}.
+  OMgetEndError : % -> Void
+  ++ OMgetEndError(dev) reads an end error token from \axiom{dev}.
+  OMgetEndObject: % -> Void
+  ++ OMgetEndObject(dev) reads an end object token from \axiom{dev}.
+  OMgetInteger  : % -> Integer
+  ++ OMgetInteger(dev) reads an integer from \axiom{dev}.
+  OMgetFloat    : % -> DoubleFloat
+  ++ OMgetFloat(dev) reads a float from \axiom{dev}.
+  OMgetVariable : % -> Symbol
+  ++ OMgetVariable(dev) reads a variable from \axiom{dev}.
+  OMgetString   : % -> String
+  ++ OMgetString(dev) reads a string from \axiom{dev}.
+  OMgetSymbol   : % -> Record(cd:String, name:String)
+  ++ OMgetSymbol(dev) reads a symbol from \axiom{dev}.
+
+  OMgetType     : % -> Symbol
+  ++ OMgetType(dev) returns the type of the next object on \axiom{dev}.
+ == add
+  OMopenFile(fname: String, fmode: String, enc: OpenMathEncoding): % ==
+    OM_-OPENFILEDEV(fname, fmode, enc)$Lisp
+  OMopenString(str: String, enc: OpenMathEncoding): % ==
+    OM_-OPENSTRINGDEV(str, enc)$Lisp
+  OMclose(dev: %): Void ==
+    OM_-CLOSEDEV(dev)$Lisp
+  OMsetEncoding(dev: %, enc: OpenMathEncoding): Void ==
+    OM_-SETDEVENCODING(dev, enc)$Lisp
+
+  OMputApp(dev: %): Void == OM_-PUTAPP(dev)$Lisp
+  OMputAtp(dev: %): Void == OM_-PUTATP(dev)$Lisp
+  OMputAttr(dev: %): Void == OM_-PUTATTR(dev)$Lisp
+  OMputBind(dev: %): Void == OM_-PUTBIND(dev)$Lisp
+  OMputBVar(dev: %): Void == OM_-PUTBVAR(dev)$Lisp
+  OMputError(dev: %): Void == OM_-PUTERROR(dev)$Lisp
+  OMputObject(dev: %): Void == OM_-PUTOBJECT(dev)$Lisp
+  OMputEndApp(dev: %): Void == OM_-PUTENDAPP(dev)$Lisp
+  OMputEndAtp(dev: %): Void == OM_-PUTENDATP(dev)$Lisp
+  OMputEndAttr(dev: %): Void == OM_-PUTENDATTR(dev)$Lisp
+  OMputEndBind(dev: %): Void == OM_-PUTENDBIND(dev)$Lisp
+  OMputEndBVar(dev: %): Void == OM_-PUTENDBVAR(dev)$Lisp
+  OMputEndError(dev: %): Void == OM_-PUTENDERROR(dev)$Lisp
+  OMputEndObject(dev: %): Void == OM_-PUTENDOBJECT(dev)$Lisp
+  OMputInteger(dev: %, i: Integer): Void == OM_-PUTINT(dev, i)$Lisp
+  OMputFloat(dev: %, f: DoubleFloat): Void == OM_-PUTFLOAT(dev, f)$Lisp
+  --OMputByteArray(dev: %, b: Array Byte): Void == OM_-PUTBYTEARRAY(dev, b)$Lisp
+  OMputVariable(dev: %, v: Symbol): Void == OM_-PUTVAR(dev, v)$Lisp
+  OMputString(dev: %, s: String): Void == OM_-PUTSTRING(dev, s)$Lisp
+  OMputSymbol(dev: %, cd: String, nm: String): Void == OM_-PUTSYMBOL(dev, cd, nm)$Lisp
+
+  OMgetApp(dev: %): Void == OM_-GETAPP(dev)$Lisp
+  OMgetAtp(dev: %): Void == OM_-GETATP(dev)$Lisp
+  OMgetAttr(dev: %): Void == OM_-GETATTR(dev)$Lisp
+  OMgetBind(dev: %): Void == OM_-GETBIND(dev)$Lisp
+  OMgetBVar(dev: %): Void == OM_-GETBVAR(dev)$Lisp
+  OMgetError(dev: %): Void == OM_-GETERROR(dev)$Lisp
+  OMgetObject(dev: %): Void == OM_-GETOBJECT(dev)$Lisp
+  OMgetEndApp(dev: %): Void == OM_-GETENDAPP(dev)$Lisp
+  OMgetEndAtp(dev: %): Void == OM_-GETENDATP(dev)$Lisp
+  OMgetEndAttr(dev: %): Void == OM_-GETENDATTR(dev)$Lisp
+  OMgetEndBind(dev: %): Void == OM_-GETENDBIND(dev)$Lisp
+  OMgetEndBVar(dev: %): Void == OM_-GETENDBVAR(dev)$Lisp
+  OMgetEndError(dev: %): Void == OM_-GETENDERROR(dev)$Lisp
+  OMgetEndObject(dev: %): Void == OM_-GETENDOBJECT(dev)$Lisp
+  OMgetInteger(dev: %): Integer == OM_-GETINT(dev)$Lisp
+  OMgetFloat(dev: %): DoubleFloat == OM_-GETFLOAT(dev)$Lisp
+  --OMgetByteArray(dev: %): Array Byte == OM_-GETBYTEARRAY(dev)$Lisp
+  OMgetVariable(dev: %): Symbol == OM_-GETVAR(dev)$Lisp
+  OMgetString(dev: %): String == OM_-GETSTRING(dev)$Lisp
+  OMgetSymbol(dev: %): Record(cd:String, name:String) == OM_-GETSYMBOL(dev)$Lisp
+
+  OMgetType(dev: %): Symbol == OM_-GETTYPE(dev)$Lisp
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OMENC OpenMathEncoding}
+\pagehead{OpenMathEncoding}{OMENC}
+\pagepic{ps/v103openmathencoding.ps}{OMENC}{1.00}
+See also:\\
+\refto{OpenMathDevice}{OMDEV}
+\refto{OpenMathConnection}{OMCONN}
+<<domain OMENC OpenMathEncoding>>=
+)abbrev domain OMENC OpenMathEncoding
+++ Author: Vilya Harvey
+++ Date Created:
+++ Date Last Updated:
+++ Basic Functions: 
+++ Related Constructors:
+++ Also See:
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ Description:
+++ \spadtype{OpenMathEncoding} is the set of valid OpenMath encodings.
+OpenMathEncoding(): SetCategory with
+  OMencodingUnknown : () -> %
+  ++ OMencodingUnknown() is the constant for unknown encoding types. If this 
+  ++ is used on an input device, the encoding will be autodetected.
+  ++ It is invalid to use it on an output device.
+  OMencodingXML     : () -> %
+  ++ OMencodingXML() is the constant for the OpenMath XML encoding.
+  OMencodingSGML    : () -> %
+  ++ OMencodingSGML() is the constant for the deprecated OpenMath SGML encoding.
+  OMencodingBinary  : () -> %
+  ++ OMencodingBinary() is the constant for the OpenMath binary encoding.
+ == add
+  Rep := SingleInteger
+
+  =(u,v) == (u=v)$Rep
+
+  import Rep
+
+  coerce(u) ==
+    u::Rep = 0$Rep => "Unknown"::OutputForm
+    u::Rep = 1$Rep => "Binary"::OutputForm
+    u::Rep = 2::Rep => "XML"::OutputForm
+    u::Rep = 3::Rep => "SGML"::OutputForm
+    error "Bogus OpenMath Encoding Type"
+
+  OMencodingUnknown(): % == 0::Rep
+  OMencodingBinary(): % == 1::Rep
+  OMencodingXML(): % == 2::Rep
+  OMencodingSGML(): % == 3::Rep
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OMERR OpenMathError}
+\pagehead{OpenMathError}{OMERR}
+\pagepic{ps/v103openmatherror.ps}{OMERR}{1.00}
+See also:\\
+\refto{OpenMathErrorKind}{OMERRK}
+<<domain OMERR OpenMathError>>=
+)abbrev domain OMERR OpenMathError
+++ Author: Vilya Harvey
+++ Date Created:
+++ Date Last Updated:
+++ Basic Functions:
+++ Related Constructors:
+++ Also See:
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ Description: \spadtype{OpenMathError} is the domain of OpenMath errors.
+OpenMathError() : SetCategory with
+  errorKind : % -> OpenMathErrorKind
+  ++ errorKind(u) returns the type of error which u represents.
+  errorInfo : % -> List Symbol
+  ++ errorInfo(u) returns information about the error u.
+  omError   : (OpenMathErrorKind, List Symbol) -> % 
+  ++ omError(k,l) creates an instance of OpenMathError.
+ == add
+  Rep := Record(err:OpenMathErrorKind, info:List Symbol)
+
+  import List String
+
+  coerce(e:%):OutputForm ==
+    OMParseError? e.err => message "Error parsing OpenMath object"
+    infoSize := #(e.info)
+    OMUnknownCD? e.err => 
+--      not one? infoSize => error "Malformed info list in OMUnknownCD"
+      not (infoSize = 1) => error "Malformed info list in OMUnknownCD"
+      message concat("Cannot handle CD ",string first e.info)
+    OMUnknownSymbol? e.err =>
+      not 2=infoSize => error "Malformed info list in OMUnknownSymbol"
+      message concat ["Cannot handle Symbol ",
+                      string e.info.2, " from CD ", string e.info.1]
+    OMReadError? e.err =>
+      message "OpenMath read error"
+    error "Malformed OpenMath Error"
+
+  omError(e:OpenMathErrorKind,i:List Symbol):% == [e,i]$Rep
+
+  errorKind(e:%):OpenMathErrorKind == e.err
+  errorInfo(e:%):List Symbol == e.info
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OMERRK OpenMathErrorKind}
+\pagehead{OpenMathErrorKind}{OMERRK}
+\pagepic{ps/v103openmatherrorkind.ps}{OMERRK}{1.00}
+See also:\\
+\refto{OpenMathError}{OMERR}
+<<domain OMERRK OpenMathErrorKind>>=
+)abbrev domain OMERRK OpenMathErrorKind
+++ Author: Vilya Harvey
+++ Date Created:
+++ Date Last Updated:
+++ Basic Functions:
+++ Related Constructors:
+++ Also See:
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ Description: \spadtype{OpenMathErrorKind} represents different kinds
+++ of OpenMath errors: specifically parse errors, unknown CD or symbol 
+++ errors, and read errors.
+OpenMathErrorKind() : SetCategory with
+  coerce           : Symbol -> %
+  ++ coerce(u) creates an OpenMath error object of an appropriate type if
+  ++ \axiom{u} is one of \axiom{OMParseError}, \axiom{OMReadError},
+  ++ \axiom{OMUnknownCD} or \axiom{OMUnknownSymbol}, otherwise it
+  ++ raises a runtime error.
+  OMParseError?    : % -> Boolean
+  ++ OMParseError?(u) tests whether u is an OpenMath parsing error.
+  OMUnknownCD?     : % -> Boolean
+  ++ OMUnknownCD?(u) tests whether u is an OpenMath unknown CD error.
+  OMUnknownSymbol? : % -> Boolean
+  ++ OMUnknownSymbol?(u) tests whether u is an OpenMath unknown symbol error.
+  OMReadError?     : % -> Boolean
+  ++ OMReadError?(u) tests whether u is an OpenMath read error.
+ == add
+  Rep := Union(parseError:"OMParseError", unknownCD:"OMUnknownCD", 
+               unknownSymbol:"OMUnknownSymbol",readError:"OMReadError")
+
+  OMParseError?(u) == (u case parseError)$Rep
+  OMUnknownCD?(u) == (u case unknownCD)$Rep
+  OMUnknownSymbol?(u) == (u case unknownSymbol)$Rep
+  OMReadError?(u) == (u case readError)$Rep
+
+  coerce(s:Symbol):% == 
+    s = OMParseError    => ["OMParseError"]$Rep
+    s = OMUnknownCD     => ["OMUnknownCD"]$Rep
+    s = OMUnknownSymbol => ["OMUnknownSymbol"]$Rep
+    s = OMReadError     => ["OMReadError"]$Rep
+    error concat(string s, " is not a valid OpenMathErrorKind.")
+
+  a = b == (a=b)$Rep
+
+  coerce(e:%):OutputForm == coerce(e)$Rep
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OP Operator}
+<<Operator.input>>=
+-- opalg.spad.pamphlet Operator.input
+)spool Operator.output
+)set message test on
+)set message auto off
+)clear all
+--S 1 of 21
+R := SQMATRIX(2, INT)
+--R 
+--R
+--R   (1)  SquareMatrix(2,Integer)
+--R                                                                 Type: Domain
+--E 1
+
+--S 2 of 21
+t := operator("tilde") :: OP(R)
+--R 
+--R
+--R   (2)  tilde
+--R                                       Type: Operator SquareMatrix(2,Integer)
+--E 2
+
+--S 3 of 21
+)set expose add constructor Operator
+--R 
+--I   Operator is now explicitly exposed in frame frame0 
+--E 3
+
+--S 4 of 21
+evaluate(t, m +-> transpose m)
+--R 
+--R
+--R   (3)  tilde
+--R                                       Type: Operator SquareMatrix(2,Integer)
+--E 4
+
+--S 5 of 21
+s : R := matrix [ [0, 1], [1, 0] ]
+--R 
+--R
+--R        +0  1+
+--R   (4)  |    |
+--R        +1  0+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 5
+
+--S 6 of 21
+rho := t * s
+--R 
+--R
+--R             +0  1+
+--R   (5)  tilde|    |
+--R             +1  0+
+--R                                       Type: Operator SquareMatrix(2,Integer)
+--E 6
+
+--S 7 of 21
+z := rho**4 - 1
+--R 
+--R
+--R                   +0  1+     +0  1+     +0  1+     +0  1+
+--R   (6)  - 1 + tilde|    |tilde|    |tilde|    |tilde|    |
+--R                   +1  0+     +1  0+     +1  0+     +1  0+
+--R                                       Type: Operator SquareMatrix(2,Integer)
+--E 7
+
+--S 8 of 21
+m:R := matrix [ [1, 2], [3, 4] ]
+--R 
+--R
+--R        +1  2+
+--R   (7)  |    |
+--R        +3  4+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 8
+
+--S 9 of 21
+z m
+--R 
+--R
+--R        +0  0+
+--R   (8)  |    |
+--R        +0  0+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 9
+
+--S 10 of 21
+rho m
+--R 
+--R
+--R        +3  1+
+--R   (9)  |    |
+--R        +4  2+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 10
+
+--S 11 of 21
+rho rho m
+--R 
+--R
+--R         +4  3+
+--R   (10)  |    |
+--R         +2  1+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 11
+
+--S 12 of 21
+(rho^3) m
+--R 
+--R
+--R         +2  4+
+--R   (11)  |    |
+--R         +1  3+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 12
+
+--S 13 of 21
+b := t * s - s * t
+--R 
+--R
+--R           +0  1+             +0  1+
+--R   (12)  - |    |tilde + tilde|    |
+--R           +1  0+             +1  0+
+--R                                       Type: Operator SquareMatrix(2,Integer)
+--E 13
+
+--S 14 of 21
+b m
+--R 
+--R
+--R         +1  - 3+
+--R   (13)  |      |
+--R         +3  - 1+
+--R                                                Type: SquareMatrix(2,Integer)
+--E 14
+
+--S 15 of 21
+L n ==
+  n = 0 => 1
+  n = 1 => x
+  (2*n-1)/n * x * L(n-1) - (n-1)/n * L(n-2)
+--R 
+--R                                                                   Type: Void
+--E 15
+
+--S 16 of 21
+dx := operator("D") :: OP(POLY FRAC INT)
+--R 
+--R
+--R   (15)  D
+--R                                   Type: Operator Polynomial Fraction Integer
+--E 16
+
+--S 17 of 21
+evaluate(dx, p +-> D(p, 'x))
+--R 
+--R
+--R   (16)  D
+--R                                   Type: Operator Polynomial Fraction Integer
+--E 17
+
+--S 18 of 21
+E n == (1 - x**2) * dx**2 - 2 * x * dx + n*(n+1)
+--R 
+--R                                                                   Type: Void
+--E 18
+
+--S 19 of 21
+L 15
+--R 
+--R   Compiling function L with type Integer -> Polynomial Fraction 
+--R      Integer 
+--R   Compiling function L as a recurrence relation.
+--R
+--R   (18)
+--R     9694845  15   35102025  13   50702925  11   37182145  9   14549535  7
+--R     ------- x   - -------- x   + -------- x   - -------- x  + -------- x
+--R       2048          2048           2048           2048          2048
+--R   + 
+--R       2909907  5   255255  3   6435
+--R     - ------- x  + ------ x  - ---- x
+--R         2048        2048       2048
+--R                                            Type: Polynomial Fraction Integer
+--E 19
+
+--S 20 of 21
+E 15
+--R 
+--R   Compiling function E with type PositiveInteger -> Operator 
+--R      Polynomial Fraction Integer 
+--R
+--R                        2      2
+--R   (19)  240 - 2x D - (x  - 1)D
+--R                                   Type: Operator Polynomial Fraction Integer
+--E 20
+
+--S 21 of 21
+(E 15)(L 15)
+--R 
+--R
+--R   (20)  0
+--R                                            Type: Polynomial Fraction Integer
+--E 21
+)spool
+)lisp (bye)
+@
+<<Operator.help>>=
+====================================================================
+Operator examples
+====================================================================
+
+Given any ring R, the ring of the Integer-linear operators over R is
+called Operator(R).  To create an operator over R, first create a
+basic operator using the operation operator, and then convert it to
+Operator(R) for the R you want.
+
+We choose R to be the two by two matrices over the integers.
+
+  R := SQMATRIX(2, INT)
+    SquareMatrix(2,Integer)
+                            Type: Domain
+
+Create the operator tilde on R.
+
+  t := operator("tilde") :: OP(R)
+    tilde
+                            Type: Operator SquareMatrix(2,Integer)
+
+Since Operator is unexposed we must either package-call operations
+from it, or expose it explicitly.  For convenience we will do the latter.
+
+Expose Operator.
+
+  )set expose add constructor Operator
+
+To attach an evaluation function (from R to R) to an operator over R,
+use evaluate(op, f) where op is an operator over R and f is a function
+R -> R.  This needs to be done only once when the operator is defined.
+Note that f must be Integer-linear (that is, f(ax+y) = a f(x) + f(y)
+for any integer a, and any x and y in R).
+
+We now attach the transpose map to the above operator t.
+
+  evaluate(t, m +-> transpose m)
+    tilde
+                       Type: Operator SquareMatrix(2,Integer)
+
+Operators can be manipulated formally as in any ring: + is the
+pointwise addition and * is composition.  Any element x of R can be
+converted to an operator op(x) over R, and the evaluation function of
+op(x) is left-multiplication by x.
+
+Multiplying on the left by this matrix swaps the two rows.
+
+  s : R := matrix [ [0, 1], [1, 0] ]
+        +0  1+
+        |    |
+        +1  0+
+                       Type: SquareMatrix(2,Integer)
+
+Can you guess what is the action of the following operator?
+
+  rho := t * s
+             +0  1+
+        tilde|    |
+             +1  0+
+                       Type: Operator SquareMatrix(2,Integer)
+
+Hint: applying rho four times gives the identity, so rho^4-1 should
+return 0 when applied to any two by two matrix.
+
+  z := rho**4 - 1
+                   +0  1+     +0  1+     +0  1+     +0  1+
+        - 1 + tilde|    |tilde|    |tilde|    |tilde|    |
+                   +1  0+     +1  0+     +1  0+     +1  0+
+                       Type: Operator SquareMatrix(2,Integer)
+
+Now check with this matrix.
+
+  m:R := matrix [ [1, 2], [3, 4] ]
+        +1  2+
+        |    |
+        +3  4+
+                       Type: SquareMatrix(2,Integer)
+
+  z m
+        +0  0+
+        |    |
+        +0  0+
+                       Type: SquareMatrix(2,Integer)
+
+As you have probably guessed by now, rho acts on matrices by rotating
+the elements clockwise.
+
+  rho m
+        +3  1+
+        |    |
+        +4  2+
+                       Type: SquareMatrix(2,Integer)
+
+  rho rho m
+         +4  3+
+         |    |
+         +2  1+
+                       Type: SquareMatrix(2,Integer)
+
+  (rho^3) m
+         +2  4+
+         |    |
+         +1  3+
+                       Type: SquareMatrix(2,Integer)
+
+Do the swapping of rows and transposition commute?  We can check by
+computing their bracket.
+
+  b := t * s - s * t
+           +0  1+             +0  1+
+         - |    |tilde + tilde|    |
+           +1  0+             +1  0+
+                       Type: Operator SquareMatrix(2,Integer)
+
+Now apply it to m.
+
+  b m
+         +1  - 3+
+         |      |
+         +3  - 1+
+                       Type: SquareMatrix(2,Integer)
+ 
+Next we demonstrate how to define a differential operator on a polynomial ring.
+
+This is the recursive definition of the n-th Legendre polynomial.
+
+  L n ==
+    n = 0 => 1
+    n = 1 => x
+    (2*n-1)/n * x * L(n-1) - (n-1)/n * L(n-2)
+                        Type: Void
+
+Create the differential operator d/dx on polynomials in x over the
+rational numbers.
+
+  dx := operator("D") :: OP(POLY FRAC INT)
+     D
+                        Type: Operator Polynomial Fraction Integer
+
+Now attach the map to it.
+
+  evaluate(dx, p +-> D(p, 'x))
+    D
+                        Type: Operator Polynomial Fraction Integer
+
+This is the differential equation satisfied by the n-th Legendre polynomial.
+
+  E n == (1 - x**2) * dx**2 - 2 * x * dx + n*(n+1)
+                        Type: Void
+
+Now we verify this for n = 15.  Here is the polynomial.
+
+  L 15
+     9694845  15   35102025  13   50702925  11   37182145  9   14549535  7
+     ------- x   - -------- x   + -------- x   - -------- x  + -------- x
+       2048          2048           2048           2048          2048
+   + 
+       2909907  5   255255  3   6435
+     - ------- x  + ------ x  - ---- x
+         2048        2048       2048
+                        Type: Polynomial Fraction Integer
+
+Here is the operator.
+
+  E 15
+    240 - 2x D - (x  - 1)D
+                        Type: Operator Polynomial Fraction Integer
+
+Here is the evaluation.
+
+  (E 15)(L 15)
+    0
+                        Type: Polynomial Fraction Integer
+
+See Also:
+o )show Operator
+o $AXIOM/doc/src/algebra/opalg.spad.dvi
+
+@
+\pagehead{Operator}{OP}
+\pagepic{ps/v103operator.ps}{OP}{1.00}
+See also:\\
+\refto{ModuleOperator}{MODOP}
+<<domain OP Operator>>=
+)abbrev domain OP Operator
+++ Author: Manuel Bronstein
+++ Date Created: 15 May 1990
+++ Date Last Updated: 12 February 1993
+++ Description:
+++ Algebra of ADDITIVE operators over a ring.
+Operator(R: Ring) == ModuleOperator(R,R)
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain OMLO OppositeMonogenicLinearOperator}
 \pagehead{OppositeMonogenicLinearOperator}{OMLO}
 \pagepic{ps/v103oppositemonogeniclinearoperator.ps}{OMLO}{1.00}
@@ -40010,6 +42984,463 @@ OrdSetInts: Export == Implement where
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OUTFORM OutputForm}
+\pagehead{OutputForm}{OUTFORM}
+\pagepic{ps/v103outputform.ps}{OUTFORM}{1.00}
+<<domain OUTFORM OutputForm>>=
+)abbrev domain OUTFORM OutputForm
+++ Keywords: output, I/O, expression
+++ SMW March/88
+++ Description:
+++ This domain is used to create and manipulate mathematical expressions
+++ for output.  It is intended to provide an insulating layer between
+++ the expression rendering software (e.g.FORTRAN, TeX, or Script) and
+++ the output coercions in the various domains.
+
+OutputForm(): SetCategory with
+        --% Printing
+        print  : $ -> Void
+          ++ print(u) prints the form u.
+        message: String -> $
+          ++ message(s) creates an form with no string quotes
+          ++ from string s.
+        messagePrint: String -> Void
+          ++ messagePrint(s) prints s without string quotes. Note:
+          ++ \spad{messagePrint(s)} is equivalent to \spad{print message(s)}.
+        --% Creation of atomic forms
+        outputForm: Integer -> $
+          ++ outputForm(n) creates an form for integer n.
+        outputForm: Symbol  -> $
+          ++ outputForm(s) creates an form for symbol s.
+        outputForm: String  -> $
+          ++ outputForm(s) creates an form for string s.
+        outputForm: DoubleFloat  -> $
+          ++ outputForm(sf) creates an form for small float sf.
+        empty   : () -> $
+          ++ empty() creates an empty form.
+
+        --% Sizings
+        width: $ -> Integer
+          ++ width(f) returns the width of form f (an integer).
+        height: $ -> Integer
+          ++ height(f) returns the height of form f (an integer).
+        width: -> Integer
+          ++ width() returns the width of the display area (an integer).
+        height: -> Integer
+          ++ height() returns the height of the display area (an integer).
+        subHeight: $ -> Integer
+          ++ subHeight(f) returns the height of form f below the base line.
+        superHeight: $ -> Integer
+          ++ superHeight(f) returns the height of form f above the base line.
+         --% Space manipulations
+        hspace: Integer -> $  ++ hspace(n) creates white space of width n.
+        vspace: Integer -> $  ++ vspace(n) creates white space of height n.
+        rspace: (Integer,Integer) -> $
+          ++ rspace(n,m) creates rectangular white space, n wide by m high.
+        --% Area adjustments
+        left: ($,Integer) -> $
+          ++ left(f,n) left-justifies form f within space of width n.
+        right: ($,Integer) -> $
+          ++ right(f,n) right-justifies form f within space of width n.
+        center: ($,Integer) -> $
+          ++ center(f,n) centers form f within space of width n.
+        left: $ -> $
+          ++ left(f) left-justifies form f in total space.
+        right: $ -> $
+          ++ right(f) right-justifies form f in total space.
+        center:   $ -> $
+          ++ center(f) centers form f in total space.
+
+        --% Area manipulations
+        hconcat:  ($,$) -> $
+          ++ hconcat(f,g) horizontally concatenate forms f and g.
+        vconcat:  ($,$) -> $
+          ++ vconcat(f,g) vertically concatenates forms f and g.
+        hconcat:  List $ -> $
+          ++ hconcat(u) horizontally concatenates all forms in list u.
+        vconcat:  List $ -> $
+          ++ vconcat(u) vertically concatenates all forms in list u.
+
+        --% Application formers
+        prefix:  ($, List $) -> $
+          ++ prefix(f,l) creates a form depicting the n-ary prefix
+          ++ application of f to a tuple of arguments given by list l.
+        infix:   ($, List $) -> $
+          ++ infix(f,l) creates a form depicting the n-ary application
+          ++ of infix operation f to a tuple of arguments l.
+        infix:   ($, $, $) -> $
+          ++ infix(op, a, b) creates a form which prints as: a op b.
+        postfix: ($, $)    -> $
+          ++ postfix(op, a)  creates a form which prints as: a op.
+        infix?: $ -> Boolean
+          ++ infix?(op) returns true if op is an infix operator,
+          ++ and false otherwise.
+        elt:     ($, List $) -> $
+          ++ elt(op,l) creates a form for application of op
+          ++ to list of arguments l.
+
+        --% Special forms
+        string:  $ -> $
+          ++ string(f) creates f with string quotes.
+        label:   ($, $) -> $
+          ++ label(n,f) gives form f an equation label n.
+        box:     $ -> $
+          ++ box(f) encloses f in a box.
+        matrix:  List List $ -> $
+          ++ matrix(llf) makes llf (a list of lists of forms) into
+          ++ a form which displays as a matrix.
+        zag:     ($, $) -> $
+          ++ zag(f,g) creates a form for the continued fraction form for f over g.
+        root:    $ -> $
+          ++ root(f) creates a form for the square root of form f.
+        root:    ($, $) -> $
+          ++ root(f,n) creates a form for the nth root of form f.
+        over:    ($, $) -> $
+          ++ over(f,g) creates a form for the vertical fraction of f over g.
+        slash:   ($, $) -> $
+          ++ slash(f,g) creates a form for the horizontal fraction of f over g.
+        assign:  ($, $) -> $
+          ++ assign(f,g) creates a form for the assignment \spad{f := g}.
+        rarrow:  ($, $) -> $
+          ++ rarrow(f,g) creates a form for the mapping \spad{f -> g}.
+        differentiate: ($, NonNegativeInteger) -> $
+          ++ differentiate(f,n) creates a form for the nth derivative of f,
+          ++ e.g. \spad{f'}, \spad{f''}, \spad{f'''},
+          ++ "f super \spad{iv}".
+        binomial: ($, $) -> $
+          ++ binomial(n,m) creates a form for the binomial coefficient of n and m.
+
+        --% Scripts
+        sub:     ($, $) -> $
+          ++ sub(f,n) creates a form for f subscripted by n.
+        super:   ($, $) -> $
+          ++ super(f,n) creates a form for f superscripted by n.
+        presub:  ($, $) -> $
+          ++ presub(f,n) creates a form for f presubscripted by n.
+        presuper:($, $) -> $
+          ++ presuper(f,n) creates a form for f presuperscripted by n.
+        scripts: ($, List $) -> $
+            ++ \spad{scripts(f, [sub, super, presuper, presub])}
+            ++  creates a form for f with scripts on all 4 corners.
+        supersub:($, List $) -> $
+            ++ supersub(a,[sub1,super1,sub2,super2,...])
+            ++ creates a form with each subscript aligned
+            ++ under each superscript.
+
+        --% Diacritical marks
+        quote:   $ -> $
+          ++ quote(f) creates the form f with a prefix quote.
+        dot:     $ -> $
+          ++ dot(f) creates the form with a one dot overhead.
+        dot:     ($, NonNegativeInteger) -> $
+          ++ dot(f,n) creates the form f with n dots overhead.
+        prime:   $ -> $
+          ++ prime(f) creates the form f followed by a suffix prime (single quote).
+        prime:   ($, NonNegativeInteger) -> $
+          ++ prime(f,n) creates the form f followed by n primes.
+        overbar: $ -> $
+          ++ overbar(f) creates the form f with an overbar.
+        overlabel: ($, $) -> $
+          ++ overlabel(x,f) creates the form f with "x overbar" over the top.
+
+        --% Plexes
+        sum:     ($)       -> $
+          ++ sum(expr) creates the form prefixing expr by a capital sigma.
+        sum:     ($, $)    -> $
+          ++ sum(expr,lowerlimit) creates the form prefixing expr by
+          ++ a capital sigma with a lowerlimit.
+        sum:     ($, $, $) -> $
+          ++ sum(expr,lowerlimit,upperlimit) creates the form prefixing expr by
+          ++ a capital sigma with both a lowerlimit and upperlimit.
+        prod:    ($)       -> $
+          ++ prod(expr) creates the form prefixing expr by a capital pi.
+        prod:    ($, $)    -> $
+          ++ prod(expr,lowerlimit) creates the form prefixing expr by
+          ++ a capital pi with a lowerlimit.
+        prod:    ($, $, $) -> $
+          ++ prod(expr,lowerlimit,upperlimit) creates the form prefixing expr by
+          ++ a capital pi with both a lowerlimit and upperlimit.
+        int:     ($)       -> $
+          ++ int(expr) creates the form prefixing expr with an integral sign.
+        int:     ($, $)    -> $
+          ++ int(expr,lowerlimit) creates the form prefixing expr by an
+          ++ integral sign with a lowerlimit.
+        int:     ($, $, $) -> $
+          ++ int(expr,lowerlimit,upperlimit) creates the form prefixing expr by
+          ++ an integral sign with both a lowerlimit and upperlimit.
+
+        --% Matchfix forms
+        brace:   $ -> $
+          ++ brace(f) creates the form enclosing f in braces (curly brackets).
+        brace:   List $ -> $
+          ++ brace(lf) creates the form separating the elements of lf
+          ++ by commas and encloses the result in curly brackets.
+        bracket: $ -> $
+          ++ bracket(f) creates the form enclosing f in square brackets.
+        bracket: List $ -> $
+          ++ bracket(lf) creates the form separating the elements of lf
+          ++ by commas and encloses the result in square brackets.
+        paren:   $ -> $
+          ++ paren(f) creates the form enclosing f in parentheses.
+        paren:   List $ -> $
+          ++ paren(lf) creates the form separating the elements of lf
+          ++ by commas and encloses the result in parentheses.
+
+        --% Separators for aggregates
+        pile:     List $ -> $
+          ++ pile(l) creates the form consisting of the elements of l which
+          ++ displays as a pile, i.e. the elements begin on a new line and
+          ++ are indented right to the same margin.
+
+        commaSeparate: List $ -> $
+          ++ commaSeparate(l) creates the form separating the elements of l
+          ++ by commas.
+        semicolonSeparate:  List $ -> $
+          ++ semicolonSeparate(l) creates the form separating the elements of l
+          ++ by semicolons.
+        blankSeparate: List $ -> $
+          ++ blankSeparate(l) creates the form separating the elements of l
+          ++ by blanks.
+        --% Specific applications
+        "=":     ($, $) -> $
+          ++ f = g creates the equivalent infix form.
+        "^=":    ($, $) -> $
+          ++ f ^= g creates the equivalent infix form.
+        "<":     ($, $) -> $
+          ++ f < g creates the equivalent infix form.
+        ">":     ($, $) -> $
+          ++ f > g creates the equivalent infix form.
+        "<=":    ($, $) -> $
+          ++ f <= g creates the equivalent infix form.
+        ">=":    ($, $) -> $
+          ++ f >= g creates the equivalent infix form.
+        "+":     ($, $) -> $
+          ++ f + g creates the equivalent infix form.
+        "-":     ($, $) -> $
+          ++ f - g creates the equivalent infix form.
+        "-":     ($)    -> $
+          ++ - f creates the equivalent prefix form.
+        "*":     ($, $) -> $
+          ++ f * g creates the equivalent infix form.
+        "/":     ($, $) -> $
+          ++ f / g creates the equivalent infix form.
+        "**":    ($, $) -> $
+          ++ f ** g creates the equivalent infix form.
+        "div":   ($, $) -> $
+          ++ f div g creates the equivalent infix form.
+        "rem":   ($, $) -> $
+          ++ f rem g creates the equivalent infix form.
+        "quo":   ($, $) -> $
+          ++ f quo g creates the equivalent infix form.
+        "exquo": ($, $) -> $
+          ++ exquo(f,g) creates the equivalent infix form.
+        "and":   ($, $) -> $
+          ++ f and g creates the equivalent infix form.
+        "or":    ($, $) -> $
+          ++ f or g creates the equivalent infix form.
+        "not":   ($)    -> $
+          ++ not f creates the equivalent prefix form.
+        SEGMENT: ($,$)  -> $
+          ++ SEGMENT(x,y) creates the infix form: \spad{x..y}.
+        SEGMENT: ($)    -> $
+          ++ SEGMENT(x) creates the prefix form: \spad{x..}.
+
+    == add
+        import NumberFormats
+
+        -- Todo:
+        --   program forms, greek letters
+        --   infix, prefix, postfix, matchfix support in OUT BOOT
+        --   labove rabove, corresponding overs.
+        --   better super script, overmark, undermark
+        --   bug in product, paren blankSeparate []
+        --   uniformize integrals, products, etc as plexes.
+
+        cons ==> CONS$Lisp
+        car  ==> CAR$Lisp
+        cdr  ==> CDR$Lisp
+
+        Rep := List $
+
+        a, b: $
+        l: List $
+        s: String
+        e: Symbol
+        n: Integer
+        nn:NonNegativeInteger
+
+        sform:    String  -> $
+        eform:    Symbol  -> $
+        iform:    Integer -> $
+
+        print x              == mathprint(x)$Lisp
+        message s            == (empty? s => empty(); s pretend $)
+        messagePrint s       == print message s
+        (a:$ = b:$):Boolean  == EQUAL(a, b)$Lisp
+        (a:$ = b:$):$        == [sform "=",     a, b]
+        coerce(a):OutputForm  == a pretend OutputForm
+        outputForm n          == n pretend $
+        outputForm e          == e pretend $
+        outputForm(f:DoubleFloat) == f pretend $
+        sform s               == s pretend $
+        eform e               == e pretend $
+        iform n               == n pretend $
+
+        outputForm s ==
+          sform concat(quote()$Character, concat(s, quote()$Character))
+
+        width(a) == outformWidth(a)$Lisp
+        height(a) == height(a)$Lisp
+        subHeight(a) == subspan(a)$Lisp
+        superHeight(a) == superspan(a)$Lisp
+        height() == 20
+        width() == 66
+
+        center(a,w)   == hconcat(hspace((w - width(a)) quo 2),a)
+        left(a,w)     == hconcat(a,hspace((w - width(a))))
+        right(a,w)    == hconcat(hspace(w - width(a)),a)
+        center(a)     == center(a,width())
+        left(a)       == left(a,width())
+        right(a)      == right(a,width())
+
+        vspace(n) ==
+          n = 0 => empty()
+          vconcat(sform " ",vspace(n - 1))
+
+        hspace(n) ==
+          n = 0 => empty()
+          sform(fillerSpaces(n)$Lisp)
+
+        rspace(n, m) ==
+          n = 0 or m = 0 => empty()
+          vconcat(hspace n, rspace(n, m - 1))
+
+        matrix ll ==
+            lv:$ := [LIST2VEC$Lisp l for l in ll]
+            CONS(eform MATRIX, LIST2VEC$Lisp lv)$Lisp
+
+        pile l              == cons(eform SC, l)
+        commaSeparate l     == cons(eform AGGLST,  l)
+        semicolonSeparate l == cons(eform AGGSET,  l)
+        blankSeparate l     ==
+           c:=eform CONCATB
+           l1:$:=[]
+           for u in reverse l repeat
+               if EQCAR(u,c)$Lisp
+                  then l1:=[:cdr u,:l1]
+                  else l1:=[u,:l1]
+           cons(c, l1)
+
+        brace a        == [eform BRACE,   a]
+        brace l        == brace commaSeparate l
+        bracket a      == [eform BRACKET, a]
+        bracket l      == bracket commaSeparate l
+        paren a        == [eform PAREN,   a]
+        paren l        == paren commaSeparate l
+
+        sub     (a,b)  == [eform SUB, a, b]
+        super   (a, b) == [eform SUPERSUB,a,sform " ",b]
+        presub(a,b) == [eform SUPERSUB,a,sform " ",sform " ",sform " ",b]
+        presuper(a, b) == [eform SUPERSUB,a,sform " ",sform " ",b]
+        scripts (a, l) ==
+            null l => a
+            null rest l => sub(a, first l)
+            cons(eform SUPERSUB, cons(a, l))
+        supersub(a, l) ==
+            if odd?(#l) then l := append(l, [empty()])
+            cons(eform ALTSUPERSUB, cons(a, l))
+
+        hconcat(a,b)  == [eform CONCAT, a, b]
+        hconcat l     == cons(eform CONCAT, l)
+        vconcat(a,b)  == [eform VCONCAT, a, b]
+        vconcat l     == cons(eform VCONCAT, l)
+
+        a ^= b      == [sform "^=",    a, b]
+        a < b       == [sform "<",     a, b]
+        a > b       == [sform ">",     a, b]
+        a <= b      == [sform "<=",    a, b]
+        a >= b      == [sform ">=",    a, b]
+
+        a + b       == [sform "+",     a, b]
+        a - b       == [sform "-",     a, b]
+        - a         == [sform "-",     a]
+        a * b       == [sform "*",     a, b]
+        a / b       == [sform "/",     a, b]
+        a ** b      == [sform "**",    a, b]
+        a div b     == [sform "div",   a, b]
+        a rem b     == [sform "rem",   a, b]
+        a quo b     == [sform "quo",   a, b]
+        a exquo b   == [sform "exquo", a, b]
+        a and b     == [sform "and",   a, b]
+        a or b      == [sform "or",    a, b]
+        not a       == [sform "not",   a]
+        SEGMENT(a,b)== [eform SEGMENT, a, b]
+        SEGMENT(a)  == [eform SEGMENT, a]
+        binomial(a,b)==[eform BINOMIAL, a, b]
+
+        empty() == [eform NOTHING]
+
+        infix? a ==
+            e:$ :=
+                IDENTP$Lisp a => a
+                STRINGP$Lisp a => INTERN$Lisp a
+                return false
+            if GET(e,QUOTE(INFIXOP$Lisp)$Lisp)$Lisp then true else false
+
+        elt(a, l) ==
+            cons(a, l)
+        prefix(a,l)   ==
+            not infix? a => cons(a, l)
+            hconcat(a, paren commaSeparate l)
+        infix(a, l) ==
+            null l => empty()
+            null rest l => first l
+            infix? a => cons(a, l)
+            hconcat [first l, a, infix(a, rest l)]
+        infix(a,b,c)  ==
+            infix? a => [a, b, c]
+            hconcat [b, a, c]
+        postfix(a, b) ==
+            hconcat(b, a)
+
+        string a   == [eform STRING,  a]
+        quote  a   == [eform QUOTE,   a]
+        overbar a  == [eform OVERBAR, a]
+        dot a      == super(a, sform ".")
+        prime a    == super(a, sform ",")
+        dot(a,nn)   == (s := new(nn, char "."); super(a, sform s))
+        prime(a,nn) == (s := new(nn, char ","); super(a, sform s))
+
+        overlabel(a,b) == [eform OVERLABEL, a, b]
+        box a      == [eform BOX,     a]
+        zag(a,b)   == [eform ZAG,     a, b]
+        root a     == [eform ROOT,    a]
+        root(a,b)  == [eform ROOT,    a, b]
+        over(a,b)  == [eform OVER,    a, b]
+        slash(a,b) == [eform SLASH,   a, b]
+        assign(a,b)== [eform LET,     a, b]
+
+        label(a,b) == [eform EQUATNUM, a, b]
+        rarrow(a,b)== [eform TAG, a, b]
+        differentiate(a, nn)==
+            zero? nn => a
+            nn < 4 => prime(a, nn)
+            r := FormatRoman(nn::PositiveInteger)
+            s := lowerCase(r::String)
+            super(a, paren sform s)
+
+        sum(a)     == [eform SIGMA,  empty(), a]
+        sum(a,b)   == [eform SIGMA,  b, a]
+        sum(a,b,c) == [eform SIGMA2, b, c, a]
+        prod(a)    == [eform PI,     empty(), a]
+        prod(a,b)  == [eform PI,     b, a]
+        prod(a,b,c)== [eform PI2,    b, c, a]
+        int(a)     == [eform INTSIGN,empty(), empty(), a]
+        int(a,b)   == [eform INTSIGN,b, empty(), a]
+        int(a,b,c) == [eform INTSIGN,b, c, a]
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Chapter P}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain PALETTE Palette}
@@ -41398,6 +44829,42 @@ PlaneAlgebraicCurvePlot(): PlottablePlaneCurveCategory _
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain POINT Point}
+\pagehead{Point}{POINT}
+\pagepic{ps/v103point.ps}{POINT}{1.00}
+See also:\\
+\refto{SubSpaceComponentProperty}{COMPPROP}
+\refto{SubSpace}{SUBSPACE}
+<<domain POINT Point>>=
+)abbrev domain POINT Point
+++ Description:
+++ This domain implements points in coordinate space
+ 
+Point(R:Ring) : Exports == Implementation where
+  -- Domains for points, subspaces and properties of components in
+  -- a subspace
+ 
+  Exports ==> PointCategory(R)
+ 
+  Implementation ==> Vector (R) add
+    PI   ==> PositiveInteger
+
+    point(l:List R):% ==
+      pt := new(#l,R)
+      for x in l for i in minIndex(pt).. repeat
+        pt.i := x
+      pt
+    dimension p == (# p)::PI  -- Vector returns NonNegativeInteger...?
+    convert(l:List R):% == point(l)
+    cross(p0, p1) ==
+      #p0 ^=3 or #p1^=3 => error "Arguments to cross must be three dimensional"      
+      point [p0.2 * p1.3 - p1.2 * p0.3, _
+             p1.1 * p0.3 - p0.1 * p1.3, _
+             p0.1 * p1.2 - p1.1 * p0.2]
+    extend(p,l) == concat(p,point l)
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain POLY Polynomial}
 <<Polynomial.input>>=
 -- multpoly.spad.pamphlet Polynomial.input
@@ -44626,6 +48093,42 @@ SingletonAsOrderedSet(): OrderedSet with
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain ORESUP SparseUnivariateSkewPolynomial}
+\pagehead{SparseUnivariateSkewPolynomial}{ORESUP}
+\pagepic{ps/v103sparseunivariateskewpolynomial.ps}{ORESUP}{1.00}
+See also:\\
+\refto{Automorphism}{AUTOMOR}
+\refto{UnivariateSkewPolynomial}{OREUP}
+<<domain ORESUP SparseUnivariateSkewPolynomial>>=
+)abbrev domain ORESUP SparseUnivariateSkewPolynomial
+++ Author: Manuel Bronstein
+++ Date Created: 19 October 1993
+++ Date Last Updated: 1 February 1994
+++ Description:
+++   This is the domain of sparse univariate skew polynomials over an Ore
+++   coefficient field.
+++   The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
+SparseUnivariateSkewPolynomial(R:Ring, sigma:Automorphism R, delta: R -> R):
+ UnivariateSkewPolynomialCategory R with
+      outputForm: (%, OutputForm) -> OutputForm
+        ++ outputForm(p, x) returns the output form of p using x for the
+        ++ otherwise anonymous variable.
+   == SparseUnivariatePolynomial R add
+      import UnivariateSkewPolynomialCategoryOps(R, %)
+ 
+      x:% * y:%      == times(x, y, sigma, delta)
+      apply(p, c, r) == apply(p, c, r, sigma, delta)
+ 
+      if R has IntegralDomain then
+          monicLeftDivide(a, b)  == monicLeftDivide(a, b, sigma)
+          monicRightDivide(a, b) == monicRightDivide(a, b, sigma)
+ 
+      if R has Field then
+          leftDivide(a, b)  == leftDivide(a, b, sigma)
+          rightDivide(a, b) == rightDivide(a, b, sigma)
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain SMP SparseMultivariatePolynomial}
 \pagehead{SparseMultivariatePolynomial}{SMP}
 \pagepic{ps/v103sparsemultivariatepolynomial.ps}{SMP}{1.00}
@@ -45529,6 +49032,476 @@ SplitHomogeneousDirectProduct(dimtot,dim1,S) : T == C where
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain SPLNODE SplittingNode}
+\pagehead{SplittingNode}{SPLNODE}
+\pagepic{ps/v103splittingnode.ps}{SPLNODE}{1.00}
+See also:\\
+\refto{SplittingNode}{SPLNODE}
+<<domain SPLNODE SplittingNode>>=
+)abbrev domain SPLNODE SplittingNode
+++ Author: Marc Moereno Maza
+++ Date Created: 07/05/1996
+++ Date Last Updated:  07/19/1996
+++ Basic Functions:
+++ Related Constructors:
+++ Also See: 
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++ References:
+++ Description: 
+++    This domain exports a modest implementation for the
+++    vertices of splitting trees. These vertices are called
+++    here splitting nodes. Every of these nodes store 3 informations. 
+++    The first one is its value, that is the current expression 
+++    to evaluate. The second one is its condition, that is the 
+++    hypothesis under which the value has to be evaluated. 
+++    The last one is its status, that is a boolean flag
+++    which is true iff the value is the result of its
+++    evaluation under its condition. Two splitting vertices
+++    are equal iff they have the sane values and the same
+++    conditions (so their status do not matter).
+
+SplittingNode(V,C) : Exports == Implementation where
+
+  V:Join(SetCategory,Aggregate)
+  C:Join(SetCategory,Aggregate)
+  Z ==> Integer
+  B ==> Boolean
+  O ==> OutputForm
+  VT ==> Record(val:V, tower:C)
+  VTB ==> Record(val:V, tower:C, flag:B)
+
+  Exports ==  SetCategory with
+
+     empty : () -> %
+       ++ \axiom{empty()} returns the same as 
+       ++ \axiom{[empty()$V,empty()$C,false]$%}
+     empty? : % -> B
+       ++ \axiom{empty?(n)} returns true iff the node n is \axiom{empty()$%}.
+     value : % -> V
+       ++ \axiom{value(n)} returns the value of the node n.
+     condition : % -> C
+       ++ \axiom{condition(n)} returns the condition of the node n.
+     status : % -> B
+       ++ \axiom{status(n)} returns the status of the node n.
+     construct : (V,C,B) -> %
+       ++ \axiom{construct(v,t,b)} returns the non-empty node with
+       ++ value v, condition t and flag b
+     construct : (V,C) -> %
+       ++ \axiom{construct(v,t)} returns the same as
+       ++ \axiom{construct(v,t,false)}
+     construct : VT ->  %
+       ++ \axiom{construct(vt)} returns the same as
+       ++ \axiom{construct(vt.val,vt.tower)}
+     construct : List VT ->  List %
+       ++ \axiom{construct(lvt)} returns the same as
+       ++ \axiom{[construct(vt.val,vt.tower) for vt in lvt]}
+     construct : (V, List C) -> List %
+       ++ \axiom{construct(v,lt)} returns the same as
+       ++ \axiom{[construct(v,t) for t in lt]}
+     copy : % -> %
+       ++ \axiom{copy(n)} returns a copy of n.
+     setValue! : (%,V) -> %
+       ++ \axiom{setValue!(n,v)} returns n whose value
+       ++ has been replaced by v if it is not 
+       ++ empty, else an error is produced.
+     setCondition! : (%,C) -> %
+       ++ \axiom{setCondition!(n,t)} returns n whose condition
+       ++ has been replaced by t if it is not 
+       ++ empty, else an error is produced.
+     setStatus!: (%,B) -> %
+       ++ \axiom{setStatus!(n,b)} returns n whose status
+       ++ has been replaced by b if it is not 
+       ++ empty, else an error is produced.
+     setEmpty! : % -> %
+       ++ \axiom{setEmpty!(n)} replaces n by \axiom{empty()$%}.
+     infLex? : (%,%,(V,V) -> B,(C,C) -> B) -> B
+       ++ \axiom{infLex?(n1,n2,o1,o2)} returns true iff
+       ++ \axiom{o1(value(n1),value(n2))} or
+       ++ \axiom{value(n1) = value(n2)} and
+       ++ \axiom{o2(condition(n1),condition(n2))}.
+     subNode? : (%,%,(C,C) -> B) -> B
+       ++ \axiom{subNode?(n1,n2,o2)} returns true iff
+       ++ \axiom{value(n1) = value(n2)} and
+       ++ \axiom{o2(condition(n1),condition(n2))}
+
+  Implementation == add
+
+     Rep ==> VTB
+
+     rep(n:%):Rep == n pretend Rep
+     per(r:Rep):% == r pretend %
+
+     empty() == per [empty()$V,empty()$C,false]$Rep
+     empty?(n:%) == empty?((rep n).val)$V and  empty?((rep n).tower)$C
+     value(n:%) == (rep n).val
+     condition(n:%) == (rep n).tower
+     status(n:%) == (rep n).flag
+     construct(v:V,t:C,b:B) ==  per [v,t,b]$Rep
+     construct(v:V,t:C) == [v,t,false]$%
+     construct(vt:VT) == [vt.val,vt.tower]$%
+     construct(lvt:List VT) == [[vt]$% for vt in lvt]
+     construct(v:V,lt: List C) == [[v,t]$% for t in lt]
+     copy(n:%) == per copy rep n
+     setValue!(n:%,v:V) == 
+        (rep n).val := v
+        n
+     setCondition!(n:%,t:C) ==
+        (rep n).tower := t
+        n
+     setStatus!(n:%,b:B) ==
+        (rep n).flag := b
+        n
+     setEmpty!(n:%) ==
+        (rep n).val := empty()$V
+        (rep n).tower := empty()$C
+        n
+     infLex?(n1,n2,o1,o2) ==
+        o1((rep n1).val,(rep n2).val) => true
+        (rep n1).val = (rep n2).val => 
+           o2((rep n1).tower,(rep n2).tower)
+        false
+     subNode?(n1,n2,o2) ==
+        (rep n1).val = (rep n2).val => 
+           o2((rep n1).tower,(rep n2).tower)
+        false
+     -- sample() == empty()
+     n1:% = n2:% ==
+        (rep n1).val ~= (rep n2).val => false
+        (rep n1).tower = (rep n2).tower
+     n1:% ~= n2:% ==
+        (rep n1).val = (rep n2).val => false
+        (rep n1).tower ~= (rep n2).tower
+     coerce(n:%):O ==
+        l1,l2,l3,l : List O
+        l1 := [message("value == "), ((rep n).val)::O]
+        o1 : O := blankSeparate l1
+        l2 := [message(" tower == "), ((rep n).tower)::O]
+        o2 : O := blankSeparate l2
+        if ((rep n).flag)
+          then
+            o3 := message(" closed == true")
+          else 
+            o3 := message(" closed == false")
+        l := [o1,o2,o3]
+        bracket commaSeparate l
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain SPLTREE SplittingTree}
+\pagehead{SplittingTree}{SPLTREE}
+\pagepic{ps/v103splittingtree.ps}{SPLTREE}{1.00}
+See also:\\
+\refto{SplittingTree}{SPLTREE}
+<<domain SPLTREE SplittingTree>>=
+)abbrev domain SPLTREE SplittingTree
+++ Author: Marc Moereno Maza
+++ Date Created: 07/05/1996
+++ Date Last Updated:  07/19/1996
+++ Basic Functions:
+++ Related Constructors:
+++ Also See: 
+++ AMS Classifications:
+++ Keywords:
+++ References:
+++      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: 
+++    This domain exports a modest implementation of splitting 
+++    trees. Spliiting trees are needed when the 
+++    evaluation of some quantity under some hypothesis
+++    requires to split the hypothesis into sub-cases.
+++    For instance by adding some new hypothesis on one
+++    hand and its negation on another hand. The computations
+++    are terminated is a splitting tree \axiom{a} when
+++    \axiom{status(value(a))} is \axiom{true}. Thus,
+++    if for the splitting tree \axiom{a} the flag
+++    \axiom{status(value(a))} is \axiom{true}, then
+++    \axiom{status(value(d))} is \axiom{true} for any
+++    subtree \axiom{d} of \axiom{a}. This property
+++    of splitting trees is called the termination
+++    condition. If no vertex in a splitting tree \axiom{a}
+++    is equal to another, \axiom{a} is said to satisfy
+++    the no-duplicates condition. The splitting 
+++    tree \axiom{a} will satisfy this condition 
+++    if nodes are added to \axiom{a} by mean of 
+++    \axiom{splitNodeOf!} and if \axiom{construct}
+++    is only used to create the root of \axiom{a}
+++    with no children.
+
+SplittingTree(V,C) : Exports == Implementation where
+
+  V:Join(SetCategory,Aggregate)
+  C:Join(SetCategory,Aggregate)
+  B ==> Boolean
+  O ==> OutputForm
+  NNI ==> NonNegativeInteger
+  VT ==> Record(val:V, tower:C)
+  VTB ==> Record(val:V, tower:C, flag:B)
+  S ==> SplittingNode(V,C)
+  A ==> Record(root:S,subTrees:List(%))
+
+  Exports ==  RecursiveAggregate(S) with
+     shallowlyMutable
+     finiteAggregate
+     extractSplittingLeaf : % -> Union(%,"failed")
+       ++ \axiom{extractSplittingLeaf(a)} returns the left
+       ++ most leaf (as a tree) whose status is false
+       ++ if any, else "failed" is returned.
+     updateStatus! : % -> %
+       ++ \axiom{updateStatus!(a)} returns a where the status
+       ++ of the vertices are updated to satisfy 
+       ++ the "termination condition".
+     construct : S -> %
+       ++ \axiom{construct(s)} creates a splitting tree
+       ++ with value (i.e. root vertex) given by
+       ++ \axiom{s} and no children. Thus, if the
+       ++ status of \axiom{s} is false, \axiom{[s]}
+       ++ represents the starting point of the 
+       ++ evaluation \axiom{value(s)} under the 
+       ++ hypothesis \axiom{condition(s)}.
+     construct : (V,C, List %) -> %
+       ++ \axiom{construct(v,t,la)} creates a splitting tree
+       ++ with value (i.e. root vertex) given by
+       ++ \axiom{[v,t]$S} and with \axiom{la} as 
+       ++ children list.
+     construct : (V,C,List S) -> %
+       ++ \axiom{construct(v,t,ls)} creates a splitting tree
+       ++ with value (i.e. root vertex) given by
+       ++ \axiom{[v,t]$S} and with children list given by
+       ++ \axiom{[[s]$% for s in ls]}.
+     construct : (V,C,V,List C) -> %
+       ++ \axiom{construct(v1,t,v2,lt)} creates a splitting tree
+       ++ with value (i.e. root vertex) given by
+       ++ \axiom{[v,t]$S} and with children list given by
+       ++ \axiom{[[[v,t]$S]$% for s in ls]}.
+     conditions : % -> List C
+       ++ \axiom{conditions(a)} returns the list of the conditions
+       ++ of the leaves of a 
+     result : % -> List VT
+       ++ \axiom{result(a)} where \axiom{ls} is the leaves list of \axiom{a}
+       ++ returns \axiom{[[value(s),condition(s)]$VT for s in ls]}
+       ++ if the computations are terminated in \axiom{a} else
+       ++ an error is produced.
+     nodeOf? : (S,%) -> B
+       ++ \axiom{nodeOf?(s,a)} returns true iff some node of \axiom{a}
+       ++ is equal to \axiom{s}
+     subNodeOf? : (S,%,(C,C) -> B) -> B
+       ++ \axiom{subNodeOf?(s,a,sub?)} returns true iff for some node
+       ++ \axiom{n} in \axiom{a} we have \axiom{s = n} or
+       ++ \axiom{status(n)} and \axiom{subNode?(s,n,sub?)}.
+     remove : (S,%) -> %
+       ++ \axiom{remove(s,a)} returns the splitting tree obtained 
+       ++ from a by removing every sub-tree \axiom{b} such
+       ++ that \axiom{value(b)} and \axiom{s} have the same
+       ++ value, condition and status.
+     remove! : (S,%) -> %
+       ++ \axiom{remove!(s,a)} replaces a by remove(s,a)
+     splitNodeOf! : (%,%,List(S)) -> %
+       ++ \axiom{splitNodeOf!(l,a,ls)} returns \axiom{a} where the children
+       ++ list of \axiom{l} has been set to
+       ++ \axiom{[[s]$% for s in ls | not nodeOf?(s,a)]}.
+       ++ Thus, if \axiom{l} is not a node of \axiom{a}, this
+       ++ latter splitting tree is unchanged.
+     splitNodeOf! : (%,%,List(S),(C,C) -> B) -> %
+       ++ \axiom{splitNodeOf!(l,a,ls,sub?)} returns \axiom{a} where the children
+       ++ list of \axiom{l} has been set to
+       ++ \axiom{[[s]$% for s in ls | not subNodeOf?(s,a,sub?)]}.
+       ++ Thus, if \axiom{l} is not a node of \axiom{a}, this
+       ++ latter splitting tree is unchanged.
+
+
+  Implementation == add
+
+     Rep ==> A
+
+     rep(n:%):Rep == n pretend Rep
+     per(r:Rep):% == r pretend %
+
+     construct(s:S) == 
+        per [s,[]]$A
+     construct(v:V,t:C,la:List(%)) ==
+        per [[v,t]$S,la]$A
+     construct(v:V,t:C,ls:List(S)) ==
+        per [[v,t]$S,[[s]$% for s in ls]]$A
+     construct(v1:V,t:C,v2:V,lt:List(C)) ==
+        [v1,t,([v2,lt]$S)@(List S)]$%
+
+     empty?(a:%) == empty?((rep a).root) and empty?((rep a).subTrees)
+     empty() == [empty()$S]$%
+
+     remove(s:S,a:%) ==
+       empty? a => a
+       (s = value(a)) and (status(s) = status(value(a))) => empty()$%
+       la := children(a)
+       lb : List % := []
+       while (not empty? la) repeat
+          lb := cons(remove(s,first la), lb)
+          la := rest la
+       lb := reverse remove(empty?,lb)
+       [value(value(a)),condition(value(a)),lb]$%
+
+     remove!(s:S,a:%) ==
+       empty? a => a
+       (s = value(a)) and (status(s) = status(value(a))) =>
+         (rep a).root := empty()$S
+         (rep a).subTrees := []
+         a
+       la := children(a)
+       lb : List % := []
+       while (not empty? la) repeat
+          lb := cons(remove!(s,first la), lb)
+          la := rest la
+       lb := reverse remove(empty()$%,lb)
+       setchildren!(a,lb)
+
+     value(a:%) == 
+        (rep a).root
+     children(a:%) == 
+        (rep a).subTrees
+     leaf?(a:%) == 
+        empty? a => false
+        empty? (rep a).subTrees
+     setchildren!(a:%,la:List(%)) == 
+        (rep a).subTrees := la
+        a
+     setvalue!(a:%,s:S) ==
+        (rep a).root := s
+        s
+     cyclic?(a:%) == false
+     map(foo:(S -> S),a:%) ==
+       empty? a => a
+       b : % := [foo(value(a))]$%
+       leaf? a => b
+       setchildren!(b,[map(foo,c) for c in children(a)])
+     map!(foo:(S -> S),a:%) ==
+       empty? a => a
+       setvalue!(a,foo(value(a)))
+       leaf? a => a
+       setchildren!(a,[map!(foo,c) for c in children(a)])
+     copy(a:%) == 
+       map(copy,a)
+     eq?(a1:%,a2:%) ==
+       error"in eq? from SPLTREE : la vache qui rit est-elle folle?"
+     nodes(a:%) == 
+       empty? a => []
+       leaf? a => [a]
+       cons(a,concat([nodes(c) for c in children(a)]))
+     leaves(a:%) ==
+       empty? a => []
+       leaf? a => [value(a)]
+       concat([leaves(c) for c in children(a)])
+     members(a:%) ==
+       empty? a => []
+       leaf? a => [value(a)]
+       cons(value(a),concat([members(c) for c in children(a)]))
+     #(a:%) ==
+       empty? a => 0$NNI
+       leaf? a => 1$NNI
+       reduce("+",[#c for c in children(a)],1$NNI)$(List NNI)
+     a1:% = a2:% ==
+       empty? a1 => empty? a2
+       empty? a2 => false
+       leaf? a1 =>
+         not leaf? a2 => false
+         value(a1) =$S value(a2)
+       leaf? a2 => false
+       value(a1) ~=$S value(a2) => false
+       children(a1) = children(a2)
+     -- sample() == [sample()$S]$%
+     localCoerce(a:%,k:NNI):O ==
+       s : String
+       if k = 1 then  s := "* " else s := "-> "
+       for i in 2..k repeat s := concat("-+",s)$String
+       ro : O := left(hconcat(message(s)$O,value(a)::O)$O)$O
+       leaf? a => ro
+       lo : List O := [localCoerce(c,k+1) for c in children(a)]
+       lo := cons(ro,lo)
+       vconcat(lo)$O
+     coerce(a:%):O ==
+       empty? a => vconcat(message(" ")$O,message("* []")$O)
+       vconcat(message(" ")$O,localCoerce(a,1))
+       
+     extractSplittingLeaf(a:%) ==
+       empty? a => "failed"::Union(%,"failed")
+       status(value(a))$S => "failed"::Union(%,"failed")
+       la := children(a)
+       empty? la => a
+       while (not empty? la) repeat
+          esl := extractSplittingLeaf(first la)
+          (esl case %) => return(esl)
+          la := rest la
+       "failed"::Union(%,"failed")
+       
+     updateStatus!(a:%) ==
+       la := children(a)
+       (empty? la) or (status(value(a))$S) => a
+       done := true
+       while (not empty? la) and done repeat
+          done := done and status(value(updateStatus! first la))
+          la := rest la
+       setStatus!(value(a),done)$S
+       a
+     
+     result(a:%) ==
+       empty? a => []
+       not status(value(a))$S => 
+          error"in result from SLPTREE : mad cow!"
+       ls : List S := leaves(a)
+       [[value(s),condition(s)]$VT for s in ls]
+
+     conditions(a:%) ==
+       empty? a => []
+       ls : List S := leaves(a)
+       [condition(s) for s in ls]
+
+     nodeOf?(s:S,a:%) ==
+       empty? a => false
+       s =$S value(a) => true
+       la := children(a)
+       while (not empty? la) and (not nodeOf?(s,first la)) repeat
+          la := rest la
+       not empty? la
+
+     subNodeOf?(s:S,a:%,sub?:((C,C) -> B)) ==
+       empty? a => false
+       -- s =$S value(a) => true
+       status(value(a)$%)$S and subNode?(s,value(a),sub?)$S => true
+       la := children(a)
+       while (not empty? la) and (not subNodeOf?(s,first la,sub?)) repeat
+          la := rest la
+       not empty? la
+
+     splitNodeOf!(l:%,a:%,ls:List(S)) ==
+       ln := removeDuplicates ls
+       la : List % := []
+       while not empty? ln repeat
+          if not nodeOf?(first ln,a)
+            then
+              la := cons([first ln]$%, la)
+          ln := rest ln
+       la := reverse la
+       setchildren!(l,la)$%
+       if empty? la then (rep l).root := [empty()$V,empty()$C,true]$S
+       updateStatus!(a)
+
+     splitNodeOf!(l:%,a:%,ls:List(S),sub?:((C,C) -> B)) ==
+       ln := removeDuplicates ls
+       la : List % := []
+       while not empty? ln repeat
+          if not subNodeOf?(first ln,a,sub?)
+            then
+              la := cons([first ln]$%, la)
+          ln := rest ln
+       la := reverse la
+       setchildren!(l,la)$%
+       if empty? la then (rep l).root := [empty()$V,empty()$C,true]$S
+       updateStatus!(a)
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain SQMATRIX SquareMatrix}
 <<SquareMatrix.input>>=
 -- matrix.spad.pamphlet SquareMatrix.input
@@ -45880,6 +49853,532 @@ Stack(S:SetCategory): StackAggregate S with
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain SUBSPACE SubSpace}
+The first argument n is the dimension of the subSpace
+
+The SubSpace domain is implemented as a tree. The root of the tree
+is the only node in which the field dataList - which points to a
+list of points over the ring, R - is defined. The children of the
+root are the top level components of the SubSpace (in 2D, these
+would be separate curves; in 3D, these would be separate surfaces).
+
+The pt field is only defined in the leaves.
+
+By way of example, consider a three dimensional subspace with
+two components - a three by three grid and a sphere. The internal
+representation of this subspace is a tree with a depth of three.
+
+The root holds a list of all the points used in the subspace (so,
+if the grid and the sphere share points, the shared points would not
+be represented redundantly but would be referenced by index).
+
+The root, in this case, has two children - the first points to the
+grid component and the second to the sphere component. The grid child
+has four children of its own - a 3x3 grid has 4 endpoints - and each
+of these point to a list of four points. To see it another way, the 
+grid (child of the root) holds a list of line components which, when
+placed one above the next, forms a grid. Each of these line components
+is a list of points.
+
+Points could be explicitly added to subspaces at any level. A path
+could be given as an argument to the addPoint() function. It is a list
+of NonNegativeIntegers and refers, in order, to the n-th child of the
+ current node. For example,
+\begin{verbatim}
+       addPoint(s,[2,3],p)
+\end{verbatim}
+would add the point p to the subspace s by going to the second child of
+the root and then the third child of that node. If the path does extend
+to the full depth of the tree, nodes are automatically added so that 
+the tree is of constant depth down any path. By not specifying the full
+path, new components could be added - e.g. for s from SubSpace(3,Float)
+\begin{verbatim}
+       addPoint(s,[],p)
+\end{verbatim}
+would create a new child to the root (a new component in N-space) and
+extend a path to a leaf of depth 3 that points to the data held in p.
+The subspace s would now have a new component which has one child
+which, in turn, has one child (the leaf). The new component is then a 
+point.
+ 
+\pagehead{SubSpace}{SUBSPACE}
+\pagepic{ps/v103subspace.ps}{SUBSPACE}{1.00}
+See also:\\
+\refto{Point}{POINT}
+\refto{SubSpaceComponentProperty}{COMPPROP}
+<<domain SUBSPACE SubSpace>>=
+)abbrev domain SUBSPACE SubSpace
+++ Description:
+++ This domain \undocumented
+SubSpace(n:PI,R:Ring) : Exports == Implementation where
+  I    ==> Integer
+  PI   ==> PositiveInteger
+  NNI  ==> NonNegativeInteger
+  L    ==> List
+  B    ==> Boolean
+  POINT ==> Point(R)
+  PROP ==> SubSpaceComponentProperty()
+  S ==> String
+  O ==> OutputForm
+  empty ==> nil  -- macro to ease conversion to new aggcat.spad
+ 
+  Exports ==> SetCategory with
+    leaf?          : % -> B
+	++ leaf?(x) \undocumented
+    root?          : % -> B
+	++ root?(x) \undocumented
+    internal?      : % -> B
+	++ internal?(x) \undocumented
+    new            : () -> %
+	++ new() \undocumented
+    subspace       : () -> %
+	++ subspace() \undocumented
+    birth          : % -> %       -- returns a pointer to the baby
+	++ birth(x) \undocumented
+    child          : (%,NNI) -> %
+	++ child(x,n) \undocumented
+    children       : % -> List %
+	++ children(x) \undocumented
+    numberOfChildren: % -> NNI
+	++ numberOfChildren(x) \undocumented
+    shallowCopy    : % -> %
+	++ shallowCopy(x) \undocumented
+    deepCopy       : % -> %
+	++ deepCopy(x) \undocumented
+    merge          : (%,%) -> %
+      ++ merge(s1,s2) the subspaces s1 and s2 into a single subspace.
+    merge          : List % -> %
+      ++ merge(ls) a list of subspaces, ls, into one subspace.
+    separate       : % -> List %
+      ++ separate(s) makes each of the components of the \spadtype{SubSpace},
+      ++ s, into a list of separate and distinct subspaces and returns
+      ++ the list.
+    addPoint       : (%,List NNI,POINT) -> %
+      ++ addPoint(s,li,p) adds the 4 dimensional point, p, to the 3 
+      ++ dimensional subspace, s. The list of non negative integers, li, 
+      ++ dictates the path to follow, or, to look at it another way, 
+      ++ points to the component in which the point is to be added.  It's 
+      ++ length should range from 0 to \spad{n - 1} where n is the dimension 
+      ++ of the subspace. If the length is \spad{n - 1}, then a specific 
+      ++ lowest level component is being referenced.  If it is less than 
+      ++ \spad{n - 1}, then some higher level component (0 indicates top 
+      ++ level component) is being referenced and a component of that level 
+      ++ with the desired point is created.  The subspace s is returned
+      ++ with the additional point.
+    addPoint2      : (%,POINT) -> %
+      ++ addPoint2(s,p) adds the 4 dimensional point, p, to the 3 
+      ++ dimensional subspace, s. 
+      ++ The subspace s is returned with the additional point.
+    addPointLast   : (%,%,POINT, NNI) -> %
+      ++ addPointLast(s,s2,li,p) adds the 4 dimensional point, p, to the 3 
+      ++ dimensional subspace, s. s2 point to the end of the subspace
+      ++ s. n is the path in the s2 component.
+      ++ The subspace s is returned with the additional point.
+    modifyPoint    : (%,List NNI,POINT) -> %
+      ++ modifyPoint(s,li,p) replaces an existing point in the 3 dimensional
+      ++ subspace, s, with the 4 dimensional point, p.  The list of non 
+      ++ negative integers, li, dictates the path to follow, or, to look at 
+      ++ it another way, points to the component in which the existing point 
+      ++ is to be modified.  An error message occurs if s is empty, otherwise
+      ++ the subspace s is returned with the point modification.
+    addPoint       : (%,List NNI,NNI) -> %
+      ++ addPoint(s,li,i) adds the 4 dimensional point indicated by the
+      ++ index location, i, to the 3 dimensional subspace, s. The list of 
+      ++ non negative integers, li, dictates the path to follow, or, to 
+      ++ look at it another way, points to the component in which the point 
+      ++ is to be added.  It's length should range from 0 to \spad{n - 1} 
+      ++ where n is the dimension of the subspace. If the length is 
+      ++ \spad{n - 1}, then a specific lowest level component is being 
+      ++ referenced.  If it is less than \spad{n - 1}, then some higher 
+      ++ level component (0 indicates top level component) is being 
+      ++ referenced and a component of that level with the desired point 
+      ++ is created.  The subspace s is returned with the additional point.
+    modifyPoint    : (%,List NNI,NNI) -> %
+      ++ modifyPoint(s,li,i) replaces an existing point in the 3 dimensional
+      ++ subspace, s, with the 4 dimensional point indicated by the index 
+      ++ location, i.  The list of non negative integers, li, dictates 
+      ++ the path to follow, or, to look at it another way, points to the 
+      ++ component in which the existing point is to be modified.  An error
+      ++ message occurs if s is empty, otherwise the subspace s is returned
+      ++ with the point modification.
+    addPoint       : (%,POINT) -> NNI
+      ++ addPoint(s,p) adds the point, p, to the 3 dimensional subspace, s,
+      ++ and returns the new total number of points in s.
+    modifyPoint    : (%,NNI,POINT) -> %
+      ++ modifyPoint(s,ind,p) modifies the point referenced by the index
+      ++ location, ind, by replacing it with the point, p in the 3 dimensional
+      ++ subspace, s.  An error message occurs if s is empty, otherwise the
+      ++ subspace s is returned with the point modification.
+ 
+    closeComponent : (%,List NNI,B)     -> %
+      ++ closeComponent(s,li,b) sets the property of the component in the
+      ++ 3 dimensional subspace, s, to be closed if b is true, or open if 
+      ++ b is false.  The list of non negative integers, li, dictates the 
+      ++ path to follow, or, to look at it another way, points to the 
+      ++ component whose closed property is to be set.  The subspace, s, 
+      ++ is returned with the component property modification.
+    defineProperty : (%,List NNI,PROP)  -> %
+      ++ defineProperty(s,li,p) defines the component property in the
+      ++ 3 dimensional subspace, s, to be that of p, where p is of the
+      ++ domain \spadtype{SubSpaceComponentProperty}.  The list of non 
+      ++ negative integers, li, dictates the path to follow, or, to look 
+      ++ at it another way, points to the component whose property is 
+      ++ being defined.  The subspace, s, is returned with the component 
+      ++ property definition.
+    traverse       : (%,List NNI) -> %
+      ++ traverse(s,li) follows the branch list of the 3 dimensional 
+      ++ subspace, s, along the path dictated by the list of non negative
+      ++ integers, li, which points to the component which has been
+      ++ traversed to.  The subspace, s, is returned, where s is now
+      ++ the subspace pointed to by li.
+    extractPoint    : %  -> POINT
+      ++ extractPoint(s) returns the point which is given by the current 
+      ++ index location into the point data field of the 3 dimensional 
+      ++ subspace s.
+    extractIndex    : % -> NNI
+      ++ extractIndex(s) returns a non negative integer which is the current 
+      ++ index of the 3 dimensional subspace s.
+    extractClosed   : %  -> B
+      ++ extractClosed(s) returns the \spadtype{Boolean} value of the closed 
+      ++ property for the indicated 3 dimensional subspace s.  If the 
+      ++ property is closed, \spad{True} is returned, otherwise \spad{False}
+      ++ is returned.
+    extractProperty : %  -> PROP
+      ++ extractProperty(s) returns the property of domain
+      ++ \spadtype{SubSpaceComponentProperty} of the indicated 3 dimensional
+      ++ subspace s.
+    level           : % -> NNI
+      ++ level(s) returns a non negative integer which is the current 
+      ++ level field of the indicated 3 dimensional subspace s.
+    parent          : % -> %
+      ++ parent(s) returns the subspace which is the parent of the indicated
+      ++ 3 dimensional subspace s.  If s is the top level subspace an error
+      ++ message is returned.
+    pointData       : % -> L POINT
+      ++ pointData(s) returns the list of points from the point data field
+      ++ of the 3 dimensional subspace s.
+ 
+  Implementation ==> add
+    import String()
+
+    Rep := Record(pt:POINT, index:NNI, property:PROP, _
+                   childrenField:List %, _
+                   lastChild: List %, _ 
+                   levelField:NNI, _
+                   pointDataField:L POINT, _
+                   lastPoint: L POINT, _
+                   noPoints: NNI, _
+                   noChildren: NNI, _
+                   parentField:List %) -- needn't be list but...base case?
+
+    TELLWATT : String := "Non-null list: Please inform Stephen Watt"
+ 
+    leaf? space ==  empty? children space
+    root? space == (space.levelField = 0$NNI)
+    internal? space == ^(root? space and leaf? space)
+ 
+    new() ==
+      [point(empty())$POINT,0,new()$PROP,empty(),empty(),0,_
+                                     empty(),empty(),0,0,empty()]
+    subspace() == new()
+ 
+    birth momma ==
+      baby := new()
+      baby.levelField := momma.levelField+1
+      baby.parentField := [momma]
+      if not empty?(lastKid := momma.lastChild) then
+        not empty? rest lastKid => error TELLWATT
+      if empty? lastKid
+        then
+          momma.childrenField := [baby]
+          momma.lastChild := momma.childrenField
+          momma.noChildren := 1
+        else
+          setrest_!(lastKid,[baby])
+          momma.lastChild := rest lastKid
+          momma.noChildren := momma.noChildren + 1
+      baby
+ 
+    child(space,num) ==
+      space.childrenField.num
+
+    children space == space.childrenField
+    numberOfChildren space == space.noChildren
+ 
+    shallowCopy space ==
+      node := new()
+      node.pt         := space.pt
+      node.index      := space.index
+      node.property   := copy(space.property)
+      node.levelField := space.levelField
+      node.parentField := nil()
+      if root? space then
+        node.pointDataField := copy(space.pointDataField)
+        node.lastPoint := tail(node.pointDataField)
+        node.noPoints := space.noPoints
+      node
+
+    deepCopy space ==
+      node := shallowCopy(space)
+      leaf? space => node
+      for c in children space repeat
+        cc := deepCopy c
+        cc.parentField := [node]
+        node.childrenField := cons(cc,node.childrenField)
+      node.childrenField := reverse_!(node.childrenField)
+      node.lastChild := tail node.childrenField
+      node
+
+    merge(s1,s2) ==
+       ------------------ need to worry about reindexing s2 & parentField
+      n1 : Rep := deepCopy s1
+      n2 : Rep := deepCopy s2
+      n1.childrenField := append(children n1,children n2)
+      n1
+
+    merge listOfSpaces ==
+       ------------------ need to worry about reindexing & parentField
+      empty? listOfSpaces => error "empty list passed as argument to merge"
+           -- notice that the properties of the first subspace on the
+           -- list are the ones that are inherited...hmmmm...
+      space := deepCopy first listOfSpaces
+      for s in rest listOfSpaces repeat
+           -- because of the initial deepCopy, above, everything is
+           -- deepCopied to be consistent...more hmmm...
+        space.childrenField := append(space.childrenField,[deepCopy c for c in s.childrenField])
+      space
+
+    separate space ==
+       ------------------ need to worry about reindexing & parentField
+      spaceList := empty()
+      for s in space.childrenField repeat
+        spc:=shallowCopy space
+        spc.childrenField:=[deepCopy s]
+        spaceList := cons(spc,spaceList)
+      spaceList
+ 
+    addPoint(space:%,path:List NNI,point:POINT) ==
+      if not empty?(lastPt := space.lastPoint) then
+        not empty? rest lastPt => error TELLWATT
+      if empty? lastPt
+        then
+          space.pointDataField := [point]
+          space.lastPoint := space.pointDataField
+        else
+          setrest_!(lastPt,[point])
+          space.lastPoint := rest lastPt
+      space.noPoints := space.noPoints + 1
+      which := space.noPoints
+      node := space
+      depth : NNI := 0
+      for i in path repeat
+        node := child(node,i)
+        depth := depth + 1
+      for more in depth..(n-1) repeat
+        node := birth node
+      node.pt := point      -- will be obsolete field
+      node.index := which
+      space
+
+    addPoint2(space:%,point:POINT) ==
+      if not empty?(lastPt := space.lastPoint) then
+        not empty? rest lastPt => error TELLWATT
+      if empty? lastPt
+        then
+          space.pointDataField := [point]
+          space.lastPoint := space.pointDataField
+        else
+          setrest_!(lastPt,[point])
+          space.lastPoint := rest lastPt
+      space.noPoints := space.noPoints + 1
+      which := space.noPoints
+      node := space
+      depth : NNI := 0
+      node := birth node
+      first := node
+      for more in 1..n-1 repeat
+        node := birth node
+      node.pt := point      -- will be obsolete field
+      node.index := which
+      first
+
+    addPointLast(space:%,node:%, point:POINT, depth:NNI) ==
+      if not empty?(lastPt := space.lastPoint) then
+        not empty? rest lastPt => error TELLWATT
+      if empty? lastPt
+        then
+          space.pointDataField := [point]
+          space.lastPoint := space.pointDataField
+        else
+          setrest_!(lastPt,[point])
+          space.lastPoint := rest lastPt
+      space.noPoints := space.noPoints + 1
+      which := space.noPoints
+      if depth = 2 then node := child(node, 2)
+      for more in depth..(n-1) repeat
+        node := birth node
+      node.pt := point      -- will be obsolete field
+      node.index := which
+      node -- space
+
+    addPoint(space:%,path:List NNI,which:NNI) ==
+      node := space
+      depth : NNI := 0
+      for i in path repeat
+        node := child(node,i)
+        depth := depth + 1
+      for more in depth..(n-1) repeat
+        node := birth node
+      node.pt := space.pointDataField.which   -- will be obsolete field
+      node.index := which
+      space
+
+    addPoint(space:%,point:POINT) ==
+      root? space =>
+        if not empty?(lastPt := space.lastPoint) then
+          not empty? rest lastPt => error TELLWATT
+        if empty? lastPt
+          then
+            space.pointDataField := [point]
+            space.lastPoint := space.pointDataField
+          else
+            setrest_!(lastPt,[point])
+            space.lastPoint := rest lastPt
+        space.noPoints := space.noPoints + 1
+      error "You need to pass a top level SubSpace (level should be zero)"
+ 
+    modifyPoint(space:%,path:List NNI,point:POINT) ==
+      if not empty?(lastPt := space.lastPoint) then
+        not empty? rest lastPt => error TELLWATT
+      if empty? lastPt
+        then
+          space.pointDataField := [point]
+          space.lastPoint := space.pointDataField
+        else
+          setrest_!(lastPt,[point])
+          space.lastPoint := rest lastPt
+      space.noPoints := space.noPoints + 1
+      which := space.noPoints
+      node := space
+      for i in path repeat
+        node := child(node,i)
+      node.pt := point       ---------- will be obsolete field
+      node.index := which
+      space
+
+    modifyPoint(space:%,path:List NNI,which:NNI) ==
+      node := space
+      for i in path repeat
+        node := child(node,i)
+      node.pt := space.pointDataField.which ---------- will be obsolete field
+      node.index := which
+      space
+
+    modifyPoint(space:%,which:NNI,point:POINT) ==
+      root? space =>
+        space.pointDataField.which := point
+        space
+      error "You need to pass a top level SubSpace (level should be zero)"
+ 
+    closeComponent(space,path,val) ==
+      node := space
+      for i in path repeat
+        node := child(node,i)
+      close(node.property,val)
+      space
+
+    defineProperty(space,path,prop) ==
+      node := space
+      for i in path repeat
+        node := child(node,i)
+      node.property := prop
+      space
+ 
+    traverse(space,path) ==
+      for i in path repeat space := child(space,i)
+      space
+
+    extractPoint space ==
+      node := space
+      while ^root? node repeat node := parent node
+      (node.pointDataField).(space.index)
+    extractIndex space == space.index
+    extractClosed space == closed? space.property
+    extractProperty space == space.property
+ 
+    parent space ==
+      empty? space.parentField => error "This is a top level SubSpace - it does not have a parent"
+      first space.parentField
+    pointData space == space.pointDataField
+    level space == space.levelField
+    s1 = s2 ==
+        ------------ extra checks for list of point data
+      (leaf? s1 and leaf? s2) =>
+        (s1.pt = s2.pt) and (s1.property = s2.property) and (s1.levelField = s2.levelField)
+      -- note that the ordering of children is important
+      #s1.childrenField ^= #s2.childrenField => false
+      and/[c1 = c2 for c1 in s1.childrenField for c2 in s2.childrenField]
+       and (s1.property = s2.property) and (s1.levelField = s2.levelField)
+    coerce(space:%):O ==
+      hconcat([n::O,"-Space with depth of "::O,                     _
+              (n - space.levelField)::O," and "::O,(s:=(#space.childrenField))::O,  _
+              (s=1 => " component"::O;" components"::O)])
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain COMPPROP SubSpaceComponentProperty}
+\pagehead{SubSpaceComponentProperty}{COMPPROP}
+\pagepic{ps/v103subspacecomponentproperty.ps}{COMPPROP}{1.00}
+See also:\\
+\refto{Point}{POINT}
+\refto{SubSpace}{SUBSPACE}
+<<domain COMPPROP SubSpaceComponentProperty>>=
+)abbrev domain COMPPROP SubSpaceComponentProperty
+++ Description:
+++ This domain implements some global properties of subspaces.
+ 
+SubSpaceComponentProperty() : Exports == Implementation where
+ 
+  O ==> OutputForm
+  I    ==> Integer
+  PI   ==> PositiveInteger
+  NNI  ==> NonNegativeInteger
+  L    ==> List
+  B    ==> Boolean
+ 
+  Exports ==> SetCategory with
+    new     : () -> %
+	++ new() \undocumented
+    closed? : % -> B
+	++ closed?(x) \undocumented
+    solid?  : % -> B
+	++ solid?(x) \undocumented
+    close   : (%,B) -> B
+	++ close(x,b) \undocumented
+    solid   : (%,B) -> B
+	++ solid(x,b) \undocumented
+    copy    : % -> %
+	++ copy(x) \undocumented
+ 
+  Implementation ==> add
+    Rep := Record(closed:B, solid:B)
+    closed? p == p.closed
+    solid? p == p.solid
+    close(p,b) == p.closed := b
+    solid(p,b) == p.solid := b
+    new() == [false,false]
+    copy p ==
+      annuderOne := new()
+      close(annuderOne,closed? p)
+      solid(annuderOne,solid? p)
+      annuderOne
+    coerce p ==
+      hconcat(["Component is "::O,
+              (closed? p => ""::O; "not "::O),"closed, "::O, _
+              (solid? p => ""::O; "not "::O),"solid"::O ])
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{domain SWITCH Switch}
 \pagehead{Switch}{SWITCH}
 \pagepic{ps/v103switch.ps}{SWITCH}{1.00}
@@ -48302,6 +52801,32 @@ UnivariatePuiseuxSeriesWithExponentialSingularity(R,FE,var,cen):_
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{domain OREUP UnivariateSkewPolynomial}
+\pagehead{UnivariateSkewPolynomial}{OREUP}
+\pagepic{ps/v103univariateskewpolynomial.ps}{OREUP}{1.00}
+See also:\\
+\refto{Automorphism}{AUTOMOR}
+\refto{SparseUnivariateSkewPolynomial}{ORESUP}
+<<domain OREUP UnivariateSkewPolynomial>>=
+)abbrev domain OREUP UnivariateSkewPolynomial
+++ Author: Manuel Bronstein
+++ Date Created: 19 October 1993
+++ Date Last Updated: 1 February 1994
+++ Description:
+++   This is the domain of univariate skew polynomials over an Ore
+++   coefficient field in a named variable.
+++   The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
+UnivariateSkewPolynomial(x:Symbol, R:Ring, sigma:Automorphism R, delta: R -> R):
+ UnivariateSkewPolynomialCategory R with
+   coerce: Variable x -> %
+     ++ coerce(x) returns x as a skew-polynomial.
+  == SparseUnivariateSkewPolynomial(R, sigma, delta) add
+     Rep := SparseUnivariateSkewPolynomial(R, sigma, delta)
+     coerce(v:Variable(x)):% == monomial(1, 1)
+     coerce(p:%):OutputForm  == outputForm(p, outputForm x)$Rep
+
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Chapter V}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -50161,6 +54686,689 @@ Note that this code is not included in the generated catdef.spad file.
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{OUTFORM.lsp BOOTSTRAP} 
+{\bf OUTFORM} depends on itself.
+We need to break this cycle to build the algebra. So we keep a
+cached copy of the translated {\bf OUTFORM} category which we can write
+into the {\bf MID} directory. We compile the lisp code and copy the
+{\bf OUTFORM.o} file to the {\bf OUT} directory.  This is eventually
+forcibly replaced by a recompiled version.
+
+Note that this code is not included in the generated catdef.spad file.
+
+<<OUTFORM.lsp BOOTSTRAP>>=
+
+(|/VERSIONCHECK| 2) 
+
+(PUT (QUOTE |OUTFORM;print;$V;1|) (QUOTE |SPADreplace|) (QUOTE |mathprint|)) 
+
+(DEFUN |OUTFORM;print;$V;1| (|x| |$|) (|mathprint| |x|)) 
+
+(DEFUN |OUTFORM;message;S$;2| (|s| |$|)
+ (COND 
+  ((SPADCALL |s| (QREFELT |$| 11)) (SPADCALL (QREFELT |$| 12)))
+  ((QUOTE T) |s|))) 
+
+(DEFUN |OUTFORM;messagePrint;SV;3| (|s| |$|)
+ (SPADCALL (SPADCALL |s| (QREFELT |$| 13)) (QREFELT |$| 8))) 
+
+(PUT (QUOTE |OUTFORM;=;2$B;4|) (QUOTE |SPADreplace|) (QUOTE EQUAL)) 
+
+(DEFUN |OUTFORM;=;2$B;4| (|a| |b| |$|) (EQUAL |a| |b|)) 
+
+(DEFUN |OUTFORM;=;3$;5| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "=" |$|) |a| |b|)) 
+
+(PUT
+ (QUOTE |OUTFORM;coerce;2$;6|)
+ (QUOTE |SPADreplace|)
+ (QUOTE (XLAM (|a|) |a|))) 
+
+(DEFUN |OUTFORM;coerce;2$;6| (|a| |$|) |a|) 
+
+(PUT
+ (QUOTE |OUTFORM;outputForm;I$;7|)
+ (QUOTE |SPADreplace|)
+ (QUOTE (XLAM (|n|) |n|))) 
+
+(DEFUN |OUTFORM;outputForm;I$;7| (|n| |$|) |n|) 
+
+(PUT
+ (QUOTE |OUTFORM;outputForm;S$;8|)
+ (QUOTE |SPADreplace|)
+ (QUOTE (XLAM (|e|) |e|))) 
+
+(DEFUN |OUTFORM;outputForm;S$;8| (|e| |$|) |e|) 
+
+(PUT
+ (QUOTE |OUTFORM;outputForm;Df$;9|)
+ (QUOTE |SPADreplace|)
+ (QUOTE (XLAM (|f|) |f|))) 
+
+(DEFUN |OUTFORM;outputForm;Df$;9| (|f| |$|) |f|) 
+
+(PUT (QUOTE |OUTFORM;sform|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|s|) |s|))) 
+
+(DEFUN |OUTFORM;sform| (|s| |$|) |s|) 
+
+(PUT (QUOTE |OUTFORM;eform|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|e|) |e|))) 
+
+(DEFUN |OUTFORM;eform| (|e| |$|) |e|) 
+
+(PUT (QUOTE |OUTFORM;iform|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|n|) |n|))) 
+
+(DEFUN |OUTFORM;iform| (|n| |$|) |n|) 
+
+(DEFUN |OUTFORM;outputForm;S$;13| (|s| |$|)
+ (|OUTFORM;sform|
+   (SPADCALL
+    (SPADCALL (QREFELT |$| 26))
+    (SPADCALL |s| (SPADCALL (QREFELT |$| 26)) (QREFELT |$| 27))
+    (QREFELT |$| 28))
+   |$|)) 
+
+(PUT
+ (QUOTE |OUTFORM;width;$I;14|)
+ (QUOTE |SPADreplace|)
+ (QUOTE |outformWidth|)) 
+
+(DEFUN |OUTFORM;width;$I;14| (|a| |$|) (|outformWidth| |a|)) 
+
+(PUT (QUOTE |OUTFORM;height;$I;15|) (QUOTE |SPADreplace|) (QUOTE |height|)) 
+
+(DEFUN |OUTFORM;height;$I;15| (|a| |$|) (|height| |a|)) 
+
+(PUT
+ (QUOTE |OUTFORM;subHeight;$I;16|)
+ (QUOTE |SPADreplace|)
+ (QUOTE |subspan|)) 
+
+(DEFUN |OUTFORM;subHeight;$I;16| (|a| |$|) (|subspan| |a|)) 
+
+(PUT
+ (QUOTE |OUTFORM;superHeight;$I;17|)
+ (QUOTE |SPADreplace|)
+ (QUOTE |superspan|)) 
+
+(DEFUN |OUTFORM;superHeight;$I;17| (|a| |$|) (|superspan| |a|)) 
+
+(PUT
+ (QUOTE |OUTFORM;height;I;18|)
+ (QUOTE |SPADreplace|)
+ (QUOTE (XLAM NIL 20))) 
+
+(DEFUN |OUTFORM;height;I;18| (|$|) 20) 
+
+(PUT
+ (QUOTE |OUTFORM;width;I;19|)
+ (QUOTE |SPADreplace|)
+ (QUOTE (XLAM NIL 66))) 
+
+(DEFUN |OUTFORM;width;I;19| (|$|) 66) 
+
+(DEFUN |OUTFORM;center;$I$;20| (|a| |w| |$|)
+ (SPADCALL
+  (SPADCALL
+   (QUOTIENT2 (|-| |w| (SPADCALL |a| (QREFELT |$| 30))) 2)
+   (QREFELT |$| 36))
+  |a|
+  (QREFELT |$| 37))) 
+
+(DEFUN |OUTFORM;left;$I$;21| (|a| |w| |$|)
+ (SPADCALL
+  |a|
+  (SPADCALL (|-| |w| (SPADCALL |a| (QREFELT |$| 30))) (QREFELT |$| 36))
+  (QREFELT |$| 37))) 
+
+(DEFUN |OUTFORM;right;$I$;22| (|a| |w| |$|)
+ (SPADCALL
+  (SPADCALL (|-| |w| (SPADCALL |a| (QREFELT |$| 30))) (QREFELT |$| 36))
+  |a|
+  (QREFELT |$| 37))) 
+
+(DEFUN |OUTFORM;center;2$;23| (|a| |$|)
+ (SPADCALL |a| (SPADCALL (QREFELT |$| 35)) (QREFELT |$| 38))) 
+
+(DEFUN |OUTFORM;left;2$;24| (|a| |$|)
+ (SPADCALL |a| (SPADCALL (QREFELT |$| 35)) (QREFELT |$| 39))) 
+
+(DEFUN |OUTFORM;right;2$;25| (|a| |$|)
+ (SPADCALL |a| (SPADCALL (QREFELT |$| 35)) (QREFELT |$| 40))) 
+
+(DEFUN |OUTFORM;vspace;I$;26| (|n| |$|)
+ (COND
+  ((EQL |n| 0) (SPADCALL (QREFELT |$| 12)))
+  ((QUOTE T)
+   (SPADCALL
+    (|OUTFORM;sform| " " |$|)
+    (SPADCALL (|-| |n| 1) (QREFELT |$| 44))
+    (QREFELT |$| 45))))) 
+
+(DEFUN |OUTFORM;hspace;I$;27| (|n| |$|)
+ (COND
+  ((EQL |n| 0) (SPADCALL (QREFELT |$| 12)))
+  ((QUOTE T) (|OUTFORM;sform| (|fillerSpaces| |n|) |$|)))) 
+
+(DEFUN |OUTFORM;rspace;2I$;28| (|n| |m| |$|)
+ (COND
+  ((OR (EQL |n| 0) (EQL |m| 0)) (SPADCALL (QREFELT |$| 12)))
+  ((QUOTE T)
+   (SPADCALL
+    (SPADCALL |n| (QREFELT |$| 36))
+    (SPADCALL |n| (|-| |m| 1) (QREFELT |$| 46))
+    (QREFELT |$| 45))))) 
+
+(DEFUN |OUTFORM;matrix;L$;29| (|ll| |$|)
+ (PROG (#1=#:G82748 |l| #2=#:G82749 |lv|)
+  (RETURN
+   (SEQ
+    (LETT |lv|
+     (PROGN
+      (LETT #1# NIL |OUTFORM;matrix;L$;29|)
+      (SEQ
+       (LETT |l| NIL |OUTFORM;matrix;L$;29|)
+       (LETT #2# |ll| |OUTFORM;matrix;L$;29|)
+       G190
+       (COND
+        ((OR
+           (ATOM #2#)
+           (PROGN (LETT |l| (CAR #2#) |OUTFORM;matrix;L$;29|) NIL))
+         (GO G191)))
+       (SEQ (EXIT (LETT #1# (CONS (LIST2VEC |l|) #1#) |OUTFORM;matrix;L$;29|)))
+       (LETT #2# (CDR #2#) |OUTFORM;matrix;L$;29|)
+       (GO G190)
+       G191
+       (EXIT (NREVERSE0 #1#))))
+     |OUTFORM;matrix;L$;29|)
+    (EXIT (CONS (|OUTFORM;eform| (QUOTE MATRIX) |$|) (LIST2VEC |lv|))))))) 
+
+(DEFUN |OUTFORM;pile;L$;30| (|l| |$|)
+ (CONS (|OUTFORM;eform| (QUOTE SC) |$|) |l|)) 
+
+(DEFUN |OUTFORM;commaSeparate;L$;31| (|l| |$|)
+ (CONS (|OUTFORM;eform| (QUOTE AGGLST) |$|) |l|)) 
+
+(DEFUN |OUTFORM;semicolonSeparate;L$;32| (|l| |$|)
+ (CONS (|OUTFORM;eform| (QUOTE AGGSET) |$|) |l|)) 
+
+(DEFUN |OUTFORM;blankSeparate;L$;33| (|l| |$|)
+ (PROG (|c| |u| #1=#:G82757 |l1|)
+  (RETURN
+   (SEQ
+    (LETT |c|
+     (|OUTFORM;eform| (QUOTE CONCATB) |$|)
+     |OUTFORM;blankSeparate;L$;33|)
+    (LETT |l1| NIL |OUTFORM;blankSeparate;L$;33|)
+    (SEQ
+     (LETT |u| NIL |OUTFORM;blankSeparate;L$;33|)
+     (LETT #1# (SPADCALL |l| (QREFELT |$| 53)) |OUTFORM;blankSeparate;L$;33|)
+     G190
+     (COND
+      ((OR
+        (ATOM #1#)
+        (PROGN (LETT |u| (CAR #1#) |OUTFORM;blankSeparate;L$;33|) NIL))
+       (GO G191)))
+     (SEQ
+      (EXIT
+       (COND
+        ((EQCAR |u| |c|)
+         (LETT |l1|
+          (SPADCALL (CDR |u|) |l1| (QREFELT |$| 54))
+          |OUTFORM;blankSeparate;L$;33|))
+        ((QUOTE T)
+         (LETT |l1| (CONS |u| |l1|) |OUTFORM;blankSeparate;L$;33|)))))
+     (LETT #1# (CDR #1#) |OUTFORM;blankSeparate;L$;33|)
+     (GO G190)
+     G191
+     (EXIT NIL))
+    (EXIT (CONS |c| |l1|)))))) 
+
+(DEFUN |OUTFORM;brace;2$;34| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE BRACE) |$|) |a|)) 
+
+(DEFUN |OUTFORM;brace;L$;35| (|l| |$|)
+ (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 56))) 
+
+(DEFUN |OUTFORM;bracket;2$;36| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE BRACKET) |$|) |a|)) 
+
+(DEFUN |OUTFORM;bracket;L$;37| (|l| |$|)
+ (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 58))) 
+
+(DEFUN |OUTFORM;paren;2$;38| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE PAREN) |$|) |a|)) 
+
+(DEFUN |OUTFORM;paren;L$;39| (|l| |$|)
+ (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 60))) 
+
+(DEFUN |OUTFORM;sub;3$;40| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SUB) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;super;3$;41| (|a| |b| |$|)
+ (LIST
+  (|OUTFORM;eform| (QUOTE SUPERSUB) |$|)
+  |a|
+  (|OUTFORM;sform| " " |$|) |b|)) 
+
+(DEFUN |OUTFORM;presub;3$;42| (|a| |b| |$|)
+ (LIST
+  (|OUTFORM;eform| (QUOTE SUPERSUB) |$|)
+  |a|
+  (|OUTFORM;sform| " " |$|)
+  (|OUTFORM;sform| " " |$|)
+  (|OUTFORM;sform| " " |$|)
+  |b|)) 
+
+(DEFUN |OUTFORM;presuper;3$;43| (|a| |b| |$|)
+ (LIST
+  (|OUTFORM;eform| (QUOTE SUPERSUB) |$|)
+  |a|
+  (|OUTFORM;sform| " " |$|)
+  (|OUTFORM;sform| " " |$|)
+  |b|)) 
+
+(DEFUN |OUTFORM;scripts;$L$;44| (|a| |l| |$|)
+ (COND
+  ((SPADCALL |l| (QREFELT |$| 66)) |a|)
+  ((SPADCALL (SPADCALL |l| (QREFELT |$| 67)) (QREFELT |$| 66))
+    (SPADCALL |a| (SPADCALL |l| (QREFELT |$| 68)) (QREFELT |$| 62)))
+  ((QUOTE T) (CONS (|OUTFORM;eform| (QUOTE SUPERSUB) |$|) (CONS |a| |l|))))) 
+
+(DEFUN |OUTFORM;supersub;$L$;45| (|a| |l| |$|)
+ (SEQ
+  (COND
+   ((ODDP (SPADCALL |l| (QREFELT |$| 71)))
+    (LETT |l|
+     (SPADCALL |l| (LIST (SPADCALL (QREFELT |$| 12))) (QREFELT |$| 73))
+     |OUTFORM;supersub;$L$;45|)))
+  (EXIT (CONS (|OUTFORM;eform| (QUOTE ALTSUPERSUB) |$|) (CONS |a| |l|))))) 
+
+(DEFUN |OUTFORM;hconcat;3$;46| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE CONCAT) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;hconcat;L$;47| (|l| |$|)
+ (CONS (|OUTFORM;eform| (QUOTE CONCAT) |$|) |l|)) 
+
+(DEFUN |OUTFORM;vconcat;3$;48| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE VCONCAT) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;vconcat;L$;49| (|l| |$|)
+ (CONS (|OUTFORM;eform| (QUOTE VCONCAT) |$|) |l|)) 
+
+(DEFUN |OUTFORM;^=;3$;50| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "^=" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;<;3$;51| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "<" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;>;3$;52| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| ">" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;<=;3$;53| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "<=" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;>=;3$;54| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| ">=" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;+;3$;55| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "+" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;-;3$;56| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "-" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;-;2$;57| (|a| |$|)
+ (LIST (|OUTFORM;sform| "-" |$|) |a|)) 
+
+(DEFUN |OUTFORM;*;3$;58| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "*" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;/;3$;59| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "/" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;**;3$;60| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "**" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;div;3$;61| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "div" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;rem;3$;62| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "rem" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;quo;3$;63| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "quo" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;exquo;3$;64| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "exquo" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;and;3$;65| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "and" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;or;3$;66| (|a| |b| |$|)
+ (LIST (|OUTFORM;sform| "or" |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;not;2$;67| (|a| |$|)
+ (LIST (|OUTFORM;sform| "not" |$|) |a|)) 
+
+(DEFUN |OUTFORM;SEGMENT;3$;68| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SEGMENT) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;SEGMENT;2$;69| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SEGMENT) |$|) |a|)) 
+
+(DEFUN |OUTFORM;binomial;3$;70| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE BINOMIAL) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;empty;$;71| (|$|)
+ (LIST (|OUTFORM;eform| (QUOTE NOTHING) |$|))) 
+
+(DEFUN |OUTFORM;infix?;$B;72| (|a| |$|)
+ (PROG (#1=#:G82802 |e|)
+  (RETURN
+   (SEQ
+    (EXIT
+     (SEQ
+      (LETT |e|
+       (COND
+        ((IDENTP |a|) |a|)
+        ((STRINGP |a|) (INTERN |a|))
+        ((QUOTE T)
+         (PROGN (LETT #1# (QUOTE NIL) |OUTFORM;infix?;$B;72|) (GO #1#))))
+       |OUTFORM;infix?;$B;72|)
+      (EXIT
+       (COND
+        ((GET |e| (QUOTE INFIXOP)) (QUOTE T))
+        ((QUOTE T) (QUOTE NIL))))))
+    #1#
+    (EXIT #1#))))) 
+
+(PUT (QUOTE |OUTFORM;elt;$L$;73|) (QUOTE |SPADreplace|) (QUOTE CONS)) 
+
+(DEFUN |OUTFORM;elt;$L$;73| (|a| |l| |$|) (CONS |a| |l|)) 
+
+(DEFUN |OUTFORM;prefix;$L$;74| (|a| |l| |$|)
+ (COND
+  ((NULL (SPADCALL |a| (QREFELT |$| 98))) (CONS |a| |l|))
+  ((QUOTE T)
+   (SPADCALL |a|
+    (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 60))
+    (QREFELT |$| 37))))) 
+
+(DEFUN |OUTFORM;infix;$L$;75| (|a| |l| |$|)
+ (COND
+  ((SPADCALL |l| (QREFELT |$| 66)) (SPADCALL (QREFELT |$| 12)))
+  ((SPADCALL (SPADCALL |l| (QREFELT |$| 67)) (QREFELT |$| 66))
+    (SPADCALL |l| (QREFELT |$| 68)))
+  ((SPADCALL |a| (QREFELT |$| 98)) (CONS |a| |l|))
+  ((QUOTE T)
+   (SPADCALL
+    (LIST
+     (SPADCALL |l| (QREFELT |$| 68))
+     |a|
+     (SPADCALL |a| (SPADCALL |l| (QREFELT |$| 101)) (QREFELT |$| 102)))
+    (QREFELT |$| 75))))) 
+
+(DEFUN |OUTFORM;infix;4$;76| (|a| |b| |c| |$|)
+ (COND
+  ((SPADCALL |a| (QREFELT |$| 98)) (LIST |a| |b| |c|))
+  ((QUOTE T) (SPADCALL (LIST |b| |a| |c|) (QREFELT |$| 75))))) 
+
+(DEFUN |OUTFORM;postfix;3$;77| (|a| |b| |$|)
+ (SPADCALL |b| |a| (QREFELT |$| 37))) 
+
+(DEFUN |OUTFORM;string;2$;78| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE STRING) |$|) |a|)) 
+
+(DEFUN |OUTFORM;quote;2$;79| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE QUOTE) |$|) |a|)) 
+
+(DEFUN |OUTFORM;overbar;2$;80| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE OVERBAR) |$|) |a|)) 
+
+(DEFUN |OUTFORM;dot;2$;81| (|a| |$|)
+ (SPADCALL |a| (|OUTFORM;sform| "." |$|) (QREFELT |$| 63))) 
+
+(DEFUN |OUTFORM;prime;2$;82| (|a| |$|)
+ (SPADCALL |a| (|OUTFORM;sform| "," |$|) (QREFELT |$| 63))) 
+
+(DEFUN |OUTFORM;dot;$Nni$;83| (|a| |nn| |$|)
+ (PROG (|s|)
+  (RETURN
+   (SEQ
+    (LETT |s|
+     (|MAKE-FULL-CVEC| |nn| (SPADCALL "." (QREFELT |$| 110)))
+     |OUTFORM;dot;$Nni$;83|)
+    (EXIT (SPADCALL |a| (|OUTFORM;sform| |s| |$|) (QREFELT |$| 63))))))) 
+
+(DEFUN |OUTFORM;prime;$Nni$;84| (|a| |nn| |$|)
+ (PROG (|s|)
+  (RETURN
+   (SEQ
+    (LETT |s|
+     (|MAKE-FULL-CVEC| |nn| (SPADCALL "," (QREFELT |$| 110)))
+     |OUTFORM;prime;$Nni$;84|)
+    (EXIT (SPADCALL |a| (|OUTFORM;sform| |s| |$|) (QREFELT |$| 63))))))) 
+
+(DEFUN |OUTFORM;overlabel;3$;85| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE OVERLABEL) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;box;2$;86| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE BOX) |$|) |a|)) 
+
+(DEFUN |OUTFORM;zag;3$;87| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE ZAG) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;root;2$;88| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE ROOT) |$|) |a|)) 
+
+(DEFUN |OUTFORM;root;3$;89| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE ROOT) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;over;3$;90| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE OVER) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;slash;3$;91| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SLASH) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;assign;3$;92| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE LET) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;label;3$;93| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE EQUATNUM) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;rarrow;3$;94| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE TAG) |$|) |a| |b|)) 
+
+(DEFUN |OUTFORM;differentiate;$Nni$;95| (|a| |nn| |$|)
+ (PROG (#1=#:G82832 |r| |s|)
+  (RETURN
+   (SEQ
+    (COND
+     ((ZEROP |nn|) |a|)
+     ((|<| |nn| 4) (SPADCALL |a| |nn| (QREFELT |$| 112)))
+     ((QUOTE T)
+      (SEQ
+       (LETT |r|
+        (SPADCALL
+         (PROG1
+          (LETT #1# |nn| |OUTFORM;differentiate;$Nni$;95|)
+          (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#))
+         (QREFELT |$| 125))
+        |OUTFORM;differentiate;$Nni$;95|)
+       (LETT |s|
+        (SPADCALL |r| (QREFELT |$| 126))
+        |OUTFORM;differentiate;$Nni$;95|)
+       (EXIT
+        (SPADCALL |a|
+         (SPADCALL (|OUTFORM;sform| |s| |$|) (QREFELT |$| 60))
+         (QREFELT |$| 63)))))))))) 
+
+(DEFUN |OUTFORM;sum;2$;96| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SIGMA) |$|) (SPADCALL (QREFELT |$| 12)) |a|)) 
+
+(DEFUN |OUTFORM;sum;3$;97| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SIGMA) |$|) |b| |a|)) 
+
+(DEFUN |OUTFORM;sum;4$;98| (|a| |b| |c| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE SIGMA2) |$|) |b| |c| |a|)) 
+
+(DEFUN |OUTFORM;prod;2$;99| (|a| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE PI) |$|) (SPADCALL (QREFELT |$| 12)) |a|)) 
+
+(DEFUN |OUTFORM;prod;3$;100| (|a| |b| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE PI) |$|) |b| |a|)) 
+
+(DEFUN |OUTFORM;prod;4$;101| (|a| |b| |c| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE PI2) |$|) |b| |c| |a|)) 
+
+(DEFUN |OUTFORM;int;2$;102| (|a| |$|)
+ (LIST
+  (|OUTFORM;eform| (QUOTE INTSIGN) |$|)
+  (SPADCALL (QREFELT |$| 12))
+  (SPADCALL (QREFELT |$| 12))
+  |a|)) 
+
+(DEFUN |OUTFORM;int;3$;103| (|a| |b| |$|)
+ (LIST
+  (|OUTFORM;eform| (QUOTE INTSIGN) |$|)
+  |b|
+  (SPADCALL (QREFELT |$| 12))
+  |a|)) 
+
+(DEFUN |OUTFORM;int;4$;104| (|a| |b| |c| |$|)
+ (LIST (|OUTFORM;eform| (QUOTE INTSIGN) |$|) |b| |c| |a|)) 
+
+(DEFUN |OutputForm| NIL
+ (PROG NIL
+  (RETURN
+   (PROG (#1=#:G82846)
+    (RETURN
+     (COND
+      ((LETT #1# (HGET |$ConstructorCache| (QUOTE |OutputForm|)) |OutputForm|)
+        (|CDRwithIncrement| (CDAR #1#)))
+      ((QUOTE T)
+       (|UNWIND-PROTECT|
+        (PROG1
+         (CDDAR
+          (HPUT |$ConstructorCache|
+           (QUOTE |OutputForm|) (LIST (CONS NIL (CONS 1 (|OutputForm;|))))))
+         (LETT #1# T |OutputForm|))
+        (COND
+         ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |OutputForm|)))))))))))) 
+
+(DEFUN |OutputForm;| NIL
+ (PROG (|dv$| |$| |pv$|)
+  (RETURN 
+   (PROGN
+    (LETT |dv$| (QUOTE (|OutputForm|)) . #1=(|OutputForm|))
+    (LETT |$| (GETREFV 138) . #1#)
+    (QSETREFV |$| 0 |dv$|)
+    (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
+    (|haddProp| |$ConstructorCache| (QUOTE |OutputForm|) NIL (CONS 1 |$|))
+    (|stuffDomainSlots| |$|) (QSETREFV |$| 6 (|List| |$|)) |$|)))) 
+
+(MAKEPROP
+ (QUOTE |OutputForm|)
+ (QUOTE |infovec|)
+ (LIST
+  (QUOTE #(
+   NIL NIL NIL NIL NIL NIL (QUOTE |Rep|) (|Void|) |OUTFORM;print;$V;1| 
+   (|Boolean|) (|String|) (0 . |empty?|) |OUTFORM;empty;$;71| 
+   |OUTFORM;message;S$;2| |OUTFORM;messagePrint;SV;3| 
+   |OUTFORM;=;2$B;4| |OUTFORM;=;3$;5| (|OutputForm|) 
+   |OUTFORM;coerce;2$;6| (|Integer|) |OUTFORM;outputForm;I$;7| 
+   (|Symbol|) |OUTFORM;outputForm;S$;8| (|DoubleFloat|) 
+   |OUTFORM;outputForm;Df$;9| (|Character|) (5 . |quote|) 
+   (9 . |concat|) (15 . |concat|) |OUTFORM;outputForm;S$;13| 
+   |OUTFORM;width;$I;14| |OUTFORM;height;$I;15| 
+   |OUTFORM;subHeight;$I;16| |OUTFORM;superHeight;$I;17| 
+   |OUTFORM;height;I;18| |OUTFORM;width;I;19| |OUTFORM;hspace;I$;27| 
+   |OUTFORM;hconcat;3$;46| |OUTFORM;center;$I$;20| 
+   |OUTFORM;left;$I$;21| |OUTFORM;right;$I$;22| |OUTFORM;center;2$;23| 
+   |OUTFORM;left;2$;24| |OUTFORM;right;2$;25| |OUTFORM;vspace;I$;26| 
+   |OUTFORM;vconcat;3$;48| |OUTFORM;rspace;2I$;28| (|List| 49) 
+   |OUTFORM;matrix;L$;29| (|List| |$|) |OUTFORM;pile;L$;30| 
+   |OUTFORM;commaSeparate;L$;31| |OUTFORM;semicolonSeparate;L$;32| 
+   (21 . |reverse|) (26 . |append|) |OUTFORM;blankSeparate;L$;33| 
+   |OUTFORM;brace;2$;34| |OUTFORM;brace;L$;35| |OUTFORM;bracket;2$;36| 
+   |OUTFORM;bracket;L$;37| |OUTFORM;paren;2$;38| |OUTFORM;paren;L$;39| 
+   |OUTFORM;sub;3$;40| |OUTFORM;super;3$;41| |OUTFORM;presub;3$;42| 
+   |OUTFORM;presuper;3$;43| (32 . |null|) (37 . |rest|) (42 . |first|) 
+   |OUTFORM;scripts;$L$;44| (|NonNegativeInteger|) (47 . |#|) 
+   (|List| |$$|) (52 . |append|) |OUTFORM;supersub;$L$;45| 
+   |OUTFORM;hconcat;L$;47| |OUTFORM;vconcat;L$;49| |OUTFORM;^=;3$;50| 
+   |OUTFORM;<;3$;51| |OUTFORM;>;3$;52| |OUTFORM;<=;3$;53| 
+   |OUTFORM;>=;3$;54| |OUTFORM;+;3$;55| |OUTFORM;-;3$;56| 
+   |OUTFORM;-;2$;57| |OUTFORM;*;3$;58| |OUTFORM;/;3$;59| 
+   |OUTFORM;**;3$;60| |OUTFORM;div;3$;61| |OUTFORM;rem;3$;62| 
+   |OUTFORM;quo;3$;63| |OUTFORM;exquo;3$;64| |OUTFORM;and;3$;65| 
+   |OUTFORM;or;3$;66| |OUTFORM;not;2$;67| |OUTFORM;SEGMENT;3$;68| 
+   |OUTFORM;SEGMENT;2$;69| |OUTFORM;binomial;3$;70| 
+   |OUTFORM;infix?;$B;72| |OUTFORM;elt;$L$;73| |OUTFORM;prefix;$L$;74| 
+   (58 . |rest|) |OUTFORM;infix;$L$;75| |OUTFORM;infix;4$;76| 
+   |OUTFORM;postfix;3$;77| |OUTFORM;string;2$;78| |OUTFORM;quote;2$;79| 
+   |OUTFORM;overbar;2$;80| |OUTFORM;dot;2$;81| |OUTFORM;prime;2$;82| 
+   (63 . |char|) |OUTFORM;dot;$Nni$;83| |OUTFORM;prime;$Nni$;84| 
+   |OUTFORM;overlabel;3$;85| |OUTFORM;box;2$;86| |OUTFORM;zag;3$;87| 
+   |OUTFORM;root;2$;88| |OUTFORM;root;3$;89| |OUTFORM;over;3$;90| 
+   |OUTFORM;slash;3$;91| |OUTFORM;assign;3$;92| 
+   |OUTFORM;label;3$;93| |OUTFORM;rarrow;3$;94| (|PositiveInteger|) 
+   (|NumberFormats|) (68 . |FormatRoman|) (73 . |lowerCase|) 
+   |OUTFORM;differentiate;$Nni$;95| |OUTFORM;sum;2$;96| 
+   |OUTFORM;sum;3$;97| |OUTFORM;sum;4$;98| |OUTFORM;prod;2$;99| 
+   |OUTFORM;prod;3$;100| |OUTFORM;prod;4$;101| |OUTFORM;int;2$;102| 
+   |OUTFORM;int;3$;103| |OUTFORM;int;4$;104| (|SingleInteger|)))  
+  (QUOTE #(|~=| 78 |zag| 84 |width| 90 |vspace| 99 |vconcat| 104 
+   |supersub| 115 |superHeight| 121 |super| 126 |sum| 132 |subHeight| 
+   150 |sub| 155 |string| 161 |slash| 166 |semicolonSeparate| 172 
+   |scripts| 177 |rspace| 183 |root| 189 |right| 200 |rem| 211 
+   |rarrow| 217 |quote| 223 |quo| 228 |prod| 234 |print| 252 
+   |prime| 257 |presuper| 268 |presub| 274 |prefix| 280 |postfix| 
+   286 |pile| 292 |paren| 297 |overlabel| 307 |overbar| 313 |over| 
+   318 |outputForm| 324 |or| 344 |not| 350 |messagePrint| 355 
+   |message| 360 |matrix| 365 |left| 370 |latex| 381 |label| 386 
+   |int| 392 |infix?| 410 |infix| 415 |hspace| 428 |height| 433 
+   |hconcat| 442 |hash| 453 |exquo| 458 |empty| 464 |elt| 468 |dot| 
+   474 |div| 485 |differentiate| 491 |commaSeparate| 497 |coerce| 
+   502 |center| 507 |bracket| 518 |brace| 528 |box| 538 |blankSeparate| 
+   543 |binomial| 548 |assign| 554 |and| 560 |^=| 566 SEGMENT 572 
+   |>=| 583 |>| 589 |=| 595 |<=| 607 |<| 613 |/| 619 |-| 625 |+| 
+   636 |**| 642 |*| 648))
+  (QUOTE NIL)
+  (CONS
+   (|makeByteWordVec2| 1 (QUOTE (0 0 0)))
+   (CONS 
+    (QUOTE #(|SetCategory&| |BasicType&| NIL))
+    (CONS
+     (QUOTE #((|SetCategory|) (|BasicType|) (|CoercibleTo| 17)))
+     (|makeByteWordVec2| 137 (QUOTE (1 10 9 0 11 0 25 0 26 2 10 0 0 25 
+       27 2 10 0 25 0 28 1 6 0 0 53 2 6 0 0 0 54 1 6 9 0 66 1 6 0 0 67 1 
+       6 2 0 68 1 6 70 0 71 2 72 0 0 0 73 1 72 0 0 101 1 25 0 10 110 1 124 
+       10 123 125 1 10 0 0 126 2 0 9 0 0 1 2 0 0 0 0 115 0 0 19 35 1 0 19 
+       0 30 1 0 0 19 44 1 0 0 49 76 2 0 0 0 0 45 2 0 0 0 49 74 1 0 19 0 
+       33 2 0 0 0 0 63 2 0 0 0 0 129 3 0 0 0 0 0 130 1 0 0 0 128 1 0 19 
+       0 32 2 0 0 0 0 62 1 0 0 0 105 2 0 0 0 0 119 1 0 0 49 52 2 0 0 0 
+       49 69 2 0 0 19 19 46 1 0 0 0 116 2 0 0 0 0 117 1 0 0 0 43 2 0 0 
+       0 19 40 2 0 0 0 0 89 2 0 0 0 0 122 1 0 0 0 106 2 0 0 0 0 90 3 0 
+       0 0 0 0 133 1 0 0 0 131 2 0 0 0 0 132 1 0 7 0 8 2 0 0 0 70 112 1 
+       0 0 0 109 2 0 0 0 0 65 2 0 0 0 0 64 2 0 0 0 49 100 2 0 0 0 0 104 
+       1 0 0 49 50 1 0 0 49 61 1 0 0 0 60 2 0 0 0 0 113 1 0 0 0 107 2 0 
+       0 0 0 118 1 0 0 10 29 1 0 0 23 24 1 0 0 21 22 1 0 0 19 20 2 0 0 
+       0 0 93 1 0 0 0 94 1 0 7 10 14 1 0 0 10 13 1 0 0 47 48 1 0 0 0 42 
+       2 0 0 0 19 39 1 0 10 0 1 2 0 0 0 0 121 3 0 0 0 0 0 136 2 0 0 0 0 
+       135 1 0 0 0 134 1 0 9 0 98 2 0 0 0 49 102 3 0 0 0 0 0 103 1 0 0 
+       19 36 0 0 19 34 1 0 19 0 31 1 0 0 49 75 2 0 0 0 0 37 1 0 137 0 1 
+       2 0 0 0 0 91 0 0 0 12 2 0 0 0 49 99 2 0 0 0 70 111 1 0 0 0 108 2 
+       0 0 0 0 88 2 0 0 0 70 127 1 0 0 49 51 1 0 17 0 18 1 0 0 0 41 2 0 
+       0 0 19 38 1 0 0 0 58 1 0 0 49 59 1 0 0 49 57 1 0 0 0 56 1 0 0 0 
+       114 1 0 0 49 55 2 0 0 0 0 97 2 0 0 0 0 120 2 0 0 0 0 92 2 0 0 0 
+       0 77 1 0 0 0 96 2 0 0 0 0 95 2 0 0 0 0 81 2 0 0 0 0 79 2 0 0 0 0 
+       16 2 0 9 0 0 15 2 0 0 0 0 80 2 0 0 0 0 78 2 0 0 0 0 86 1 0 0 0 84 
+       2 0 0 0 0 83 2 0 0 0 0 82 2 0 0 0 0 87 2 0 0 0 0 85))))))
+  (QUOTE |lookupComplete|))) 
+
+(MAKEPROP (QUOTE |OutputForm|) (QUOTE NILADIC) T) 
+@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{PI.lsp BOOTSTRAP}
 {\bf PI} depends on itself. We need to break this cycle to build
 the algebra. So we keep a cached copy of the translated {\bf PI}
@@ -50560,6 +55768,7 @@ Note that this code is not included in the generated catdef.spad file.
 \chapter{Chunk collections}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 <<algebra>>=
+<<domain ALGSC AlgebraGivenByStructuralConstants>>
 <<domain ALGFF AlgebraicFunctionField>>
 <<domain AN AlgebraicNumber>>
 <<domain ANTISYM AntiSymm>>
@@ -50597,8 +55806,10 @@ Note that this code is not included in the generated catdef.spad file.
 <<domain JORDAN AssociatedJordanAlgebra>>
 <<domain LIE AssociatedLieAlgebra>>
 <<domain ALIST AssociationList>>
+<<domain AUTOMOR Automorphism>>
 
 <<domain BFUNCT BasicFunctions>>
+<<domain BOP BasicOperator>>
 <<domain BINFILE BinaryFile>>
 <<domain BITS Bits>>
 <<domain BOOLEAN Boolean>>
@@ -50745,11 +55956,14 @@ Note that this code is not included in the generated catdef.spad file.
 <<domain MODMONOM ModuleMonomial>>
 <<domain MODFIELD ModularField>>
 <<domain MODRING ModularRing>>
+<<domain MODOP ModuleOperator>>
 <<domain MOEBIUS MoebiusTransform>>
 <<domain MRING MonoidRing>>
 <<domain MSET Multiset>>
 <<domain MPOLY MultivariatePolynomial>>
 
+<<domain NSMP NewSparseMultivariatePolynomial>>
+<<domain NSUP NewSparseUnivariatePolynomial>>
 <<domain NONE None>>
 <<domain NNI NonNegativeInteger>>
 <<domain NIPROB NumericalIntegrationProblem>>
@@ -50757,9 +55971,16 @@ Note that this code is not included in the generated catdef.spad file.
 <<domain OPTPROB NumericalOptimizationProblem>>
 <<domain PDEPROB NumericalPDEProblem>>
 
+<<domain OCT Octonion>>
 <<domain ODEIFTBL ODEIntensityFunctionsTable>>
 <<domain ARRAY1 OneDimensionalArray>>
 <<domain ONECOMP OnePointCompletion>>
+<<domain OMCONN OpenMathConnection>>
+<<domain OMDEV OpenMathDevice>>
+<<domain OMENC OpenMathEncoding>>
+<<domain OMERR OpenMathError>>
+<<domain OMERRK OpenMathErrorKind>>
+<<domain OP Operator>>
 <<domain OMLO OppositeMonogenicLinearOperator>>
 <<domain ORDCOMP OrderedCompletion>>
 <<domain ODP OrderedDirectProduct>>
@@ -50767,10 +55988,12 @@ Note that this code is not included in the generated catdef.spad file.
 <<domain ODVAR OrderlyDifferentialVariable>>
 <<domain ODR OrdinaryDifferentialRing>>
 <<domain OSI OrdSetInts>>
+<<domain OUTFORM OutputForm>>
 
 <<domain ACPLOT PlaneAlgebraicCurvePlot>>
 <<domain PALETTE Palette>>
 <<domain HACKPI Pi>>
+<<domain POINT Point>>
 <<domain POLY Polynomial>>
 <<domain IDEAL PolynomialIdeals>>
 <<domain PI PositiveInteger>>
@@ -50795,9 +56018,14 @@ Note that this code is not included in the generated catdef.spad file.
 <<domain SETMN SetOfMIntegersInOneToN>>
 <<domain SMP SparseMultivariatePolynomial>>
 <<domain SMTS SparseMultivariateTaylorSeries>>
+<<domain ORESUP SparseUnivariateSkewPolynomial>>
 <<domain SHDP SplitHomogeneousDirectProduct>>
+<<domain SPLNODE SplittingNode>>
+<<domain SPLTREE SplittingTree>>
 <<domain SQMATRIX SquareMatrix>>
 <<domain STACK Stack>>
+<<domain SUBSPACE SubSpace>>
+<<domain COMPPROP SubSpaceComponentProperty>>
 <<domain SWITCH Switch>>
 <<domain SYMTAB SymbolTable>>
 
@@ -50811,66 +56039,10 @@ Note that this code is not included in the generated catdef.spad file.
 <<domain ULS UnivariateLaurentSeries>>
 <<domain ULSCONS UnivariateLaurentSeriesConstructor>>
 <<domain UPXSSING UnivariatePuiseuxSeriesWithExponentialSingularity>>
+<<domain OREUP UnivariateSkewPolynomial>>
 
 @
-\begin{thebibliography}{99}
-\bibitem{1} Lounesto, P.
-"Clifford algebras and spinors",
-2nd edition, Cambridge University Press (2001)
-\bibitem{2} Porteous, I.,
-"Clifford algebras and the classical groups",
-Cambridge University Press (1995)
-Van Nostrand Reinhold, (1969)
-\bibitem{3} Bergdolt, G.
-"Orthonormal basis sets in Clifford algebras",
-in \cite{16} (1996)
-\bibitem{4} Dorst, Leo, 
-"Honing geometric algebra for its use in the computer sciences",
-pp127-152 from \cite{15} (2001)
-\bibitem{5} Braden, H.W., 
-"N-dimensional spinors: Their properties in terms of finite groups",
-American Institute of Physics,
-J. Math. Phys. 26(4), April 1985
-\bibitem{6} Lam, T.Y. and Smith, Tara L.,
-"On the Clifford-Littlewood-Eckmann groups: a new look at periodicity mod 8",
-Rocky Mountains Journal of Mathematics, vol 19, no. 3, (Summer 1989)
-\bibitem{7} Leopardi, Paul "Quick Introduction to Clifford Algebras"\\
-{\bf http://web.maths.unsw.edu.au/~leopardi/clifford-2003-06-05.pdf}
-\bibitem{8} Cartan, Elie and Study, Eduard
-"Nombres Complexes",
-Encyclopaedia Sciences Math\'ematique, \'edition fran\c caise, 15, (1908),
-d'apr\`es l'article allemand de Eduard Study, pp329-468. Reproduced as
-pp107-246 of \cite{17} 
-\bibitem{9} Hestenes, David and Sobczyck, Garret
-"Clifford algebra to geometric calculus: a unified language for 
-mathematics and physics", D. Reidel, (1984)
-\bibitem{10} Wene, G.P.,
-"The Idempotent structure of an infinite dimensional Clifford algebra",
-pp161-164 of \cite{13} (1995)
-\bibitem{11} Ashdown, M. 
-"GA Package for Maple V",\\
-http://www.mrao.cam.ac.uk/~clifford/software/GA/GAhelp5.html
-\bibitem{12} Doran, Chris and Lasenby, Anthony, 
-"Geometric Algebra for Physicists" 
-Cambridge University Press (2003) ISBN 0-521-48022-1
-\bibitem{13} Micali, A., Boudet, R., Helmstetter, J. (eds),
-"Clifford algebras and their applications in mathematical physics:
-proceedings of second workshop held at Montpellier, France, 1989",
-Kluwer Academic Publishers (1992)
-\bibitem{14} Porteous, I.,
-"Topological geometry"
-Van Nostrand Reinhold, (1969)
-\bibitem{15} Sommer, G. (editor),
-"Geometric Computing with Clifford Algebras",
-Springer, (2001)
-\bibitem{16} Ablamowicz, R., Lounesto, P., Parra, J.M. (eds)
-"Clifford algebras with numeric and symbolic computations",
-Birkh\"auser (1996)
-\bibitem{17} Cartan, Elie and Montel, P. (eds), 
-"\OE uvres Compl\`etes" Gauthier-Villars, (1953)
-\end{thebibliography}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Index}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\printindex
 \end{document}
diff --git a/books/ps/v103algebragivenbystructuralconstants.ps b/books/ps/v103algebragivenbystructuralconstants.ps
new file mode 100644
index 0000000..3c2ff75
--- /dev/null
+++ b/books/ps/v103algebragivenbystructuralconstants.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 266 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 266 80
+%%PageOrientation: Portrait
+gsave
+36 36 230 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+228 42 lineto
+228 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+228 42 lineto
+228 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% AlgebraGivenByStructuralConstants
+[ /Rect [ 0 0 222 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=ALGSC) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 222 36 moveto
+0 36 lineto
+0 0 lineto
+222 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 222 36 moveto
+0 36 lineto
+0 0 lineto
+222 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(AlgebraGivenByStructuralConstants)
+[10.08 3.84 6.72 6.24 6.96 4.8 6.24 10.08 3.84 6.48 6.24 6.96 9.36 6.96 7.44 3.84 5.04 6.96 6.24 3.84 6.96 4.8 6.24 3.84 9.36 6.96 6.96 5.28 4.08 6.24 6.96 3.84 5.52]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103automorphism.ps b/books/ps/v103automorphism.ps
new file mode 100644
index 0000000..8510bd2
--- /dev/null
+++ b/books/ps/v103automorphism.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 146 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 146 80
+%%PageOrientation: Portrait
+gsave
+36 36 110 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+108 42 lineto
+108 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+108 42 lineto
+108 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% Automorphism
+[ /Rect [ 0 0 102 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=AUTOMOR) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 102 36 moveto
+0 36 lineto
+0 0 lineto
+102 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 102 36 moveto
+0 36 lineto
+0 0 lineto
+102 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(Automorphism)
+[9.6 6.96 3.84 6.96 10.8 6.96 5.04 6.96 6.96 3.84 5.52 10.8]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103basicoperator.ps b/books/ps/v103basicoperator.ps
new file mode 100644
index 0000000..8847dd6
--- /dev/null
+++ b/books/ps/v103basicoperator.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 142 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 142 80
+%%PageOrientation: Portrait
+gsave
+36 36 106 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+104 42 lineto
+104 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+104 42 lineto
+104 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% BasicOperator
+[ /Rect [ 0 0 98 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=BOP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 98 36 moveto
+0 36 lineto
+0 0 lineto
+98 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 98 36 moveto
+0 36 lineto
+0 0 lineto
+98 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(BasicOperator)
+[9.36 6.24 5.52 3.84 6.24 10.08 6.96 6.24 4.8 6.24 3.84 6.96 4.8]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103moduleoperator.ps b/books/ps/v103moduleoperator.ps
new file mode 100644
index 0000000..4eed7a3
--- /dev/null
+++ b/books/ps/v103moduleoperator.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 154 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 154 80
+%%PageOrientation: Portrait
+gsave
+36 36 118 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+116 42 lineto
+116 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+116 42 lineto
+116 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% ModuleOperator
+[ /Rect [ 0 0 110 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=MODOP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 110 36 moveto
+0 36 lineto
+0 0 lineto
+110 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 110 36 moveto
+0 36 lineto
+0 0 lineto
+110 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(ModuleOperator)
+[12.48 6.96 6.96 6.96 3.84 6.24 10.08 6.96 6.24 4.8 6.24 3.84 6.96 4.8]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103newsparsemultivariatepolynomial.ps b/books/ps/v103newsparsemultivariatepolynomial.ps
new file mode 100644
index 0000000..ce954c5
--- /dev/null
+++ b/books/ps/v103newsparsemultivariatepolynomial.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 256 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 256 80
+%%PageOrientation: Portrait
+gsave
+36 36 220 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+218 42 lineto
+218 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+218 42 lineto
+218 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% NewSparseMultivariatePolynomial
+[ /Rect [ 0 0 212 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=NSMP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 212 36 moveto
+0 36 lineto
+0 0 lineto
+212 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 212 36 moveto
+0 36 lineto
+0 0 lineto
+212 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(NewSparseMultivariatePolynomial)
+[9.84 5.76 10.08 7.68 6.96 6.24 4.8 5.52 6.24 12.48 6.96 3.84 3.84 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103newsparseunivariatepolynomial.ps b/books/ps/v103newsparseunivariatepolynomial.ps
new file mode 100644
index 0000000..0d748a1
--- /dev/null
+++ b/books/ps/v103newsparseunivariatepolynomial.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 246 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 246 80
+%%PageOrientation: Portrait
+gsave
+36 36 210 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+208 42 lineto
+208 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+208 42 lineto
+208 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% NewSparseUnivariatePolynomial
+[ /Rect [ 0 0 202 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=NSUP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 202 36 moveto
+0 36 lineto
+0 0 lineto
+202 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 202 36 moveto
+0 36 lineto
+0 0 lineto
+202 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(NewSparseUnivariatePolynomial)
+[9.84 5.76 10.08 7.68 6.96 6.24 4.8 5.52 6.24 9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103octonion.ps b/books/ps/v103octonion.ps
new file mode 100644
index 0000000..5c863a1
--- /dev/null
+++ b/books/ps/v103octonion.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 112 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 112 80
+%%PageOrientation: Portrait
+gsave
+36 36 76 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+74 42 lineto
+74 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+74 42 lineto
+74 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% Octonion
+[ /Rect [ 0 0 68 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OCT) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 68 36 moveto
+0 36 lineto
+0 0 lineto
+68 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 68 36 moveto
+0 36 lineto
+0 0 lineto
+68 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(Octonion)
+[10.08 6.24 3.84 6.96 6.96 3.84 6.96 6.96]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103octoniongraph.eps b/books/ps/v103octoniongraph.eps
new file mode 100644
index 0000000..68a7a22
--- /dev/null
+++ b/books/ps/v103octoniongraph.eps
@@ -0,0 +1,1010 @@
+%!PS-Adobe-3.0 EPSF-3.0
+%%Creator: GIMP PostScript file plugin V 1.17 by Peter Kirchgessner
+%%Title: octonion1.eps
+%%CreationDate: Sat Dec 13 01:04:17 2008
+%%DocumentData: Clean7Bit
+%%LanguageLevel: 2
+%%Pages: 1
+%%BoundingBox: 14 14 271 271
+%%EndComments
+%%BeginProlog
+% Use own dictionary to avoid conflicts
+10 dict begin
+%%EndProlog
+%%Page: 1 1
+% Translate for offset
+14.173228346456694 14.173228346456694 translate
+% Translate to begin of first scanline
+0 255.99685039370078 translate
+255.99685039370078 -255.99685039370078 scale
+% Image geometry
+256 256 8
+% Transformation matrix
+[ 256 0 0 256 0 0 ]
+% Strings to hold RGB-samples per scanline
+/rstr 256 string def
+/gstr 256 string def
+/bstr 256 string def
+{currentfile /ASCII85Decode filter /RunLengthDecode filter rstr readstring pop}
+{currentfile /ASCII85Decode filter /RunLengthDecode filter gstr readstring pop}
+{currentfile /ASCII85Decode filter /RunLengthDecode filter bstr readstring pop}
+true 3
+%%BeginData:        46988 ASCII Bytes
+colorimage
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+M#RQpD]X0%DZb5*Df1=0J,~>
+M#RQpD]X0%DZb5*Df1=0J,~>
+M#RQpD]X0%DZb5*Df1=0J,~>
+NW0:`s)&m%aT);>rVm0&s8U/a*cD#WMuS;~>
+NW0:`s)&m%aT);>rVm0&s8U/a*cD#WMuS;~>
+NW0:`s)&m%aT);>rVm0&s8U/a*cD#WMuS;~>
+O8fF`s*#L)s8M]k#6+YD*I%P_NW4M~>
+O8fF`s*#L)s8M]k#6+YD*I%P_NW4M~>
+O8fF`s*#L)s8M]k#6+YD*I%P_NW4M~>
+OoGR`s*#L)mJd=1*I%P_O8j_~>
+OoGR`s*#L)mJd=1*I%P_O8j_~>
+OoGR`s*#L)mJd=1*I%P_O8j_~>
+P5bX`dN$?mrr^=^df,@.J,~>
+P5bX`dN$?mrr^=^df,@.J,~>
+P5bX`dN$?mrr^=^df,@.J,~>
+P5bR1*9I2$*79lJJ,~>
+P5bR1*9I2$*79lJJ,~>
+P5bR1*9I2$*79lJJ,~>
+PQ(Y(GN8](G9)hGJ,~>
+PQ(Y(GN8](G9)hGJ,~>
+PQ(Y(GN8](G9)hGJ,~>
+PlCe)df/;,!rgUfP5g%~>
+PlCe)df/;,!rgUfP5g%~>
+PlCe)df/;,!rgUfP5g%~>
+Q2^n+df/5*!rgUgPQ-.~>
+Q2^n+df/5*!rgUgPQ-.~>
+Q2^n+df/5*!rgUgPQ-.~>
+Qi@0ed<GTIrr`7EdJfF2J,~>
+Qi@0ed<GTIrr`7EdJfF2J,~>
+Qi@0ed<GTIrr`7EdJfF2J,~>
+Qi@*.*;9C4roa:^*6FKGJ,~>
+Qi@*.*;9C4roa:^*6FKGJ,~>
+Qi@*.*;9C4roa:^*6FKGJ,~>
+Qi@%*qu6k\2Zj$a7EXcm!$%:(J,~>
+Qi@%*qu6k\2Zj$a7EXcm!$%:(J,~>
+Qi@%*qu6k\2Zj$a7EXcm!$%:(J,~>
+RK!NkGL?Eirr8A]!!&ALrr`8JGQ*s/J,~>
+RK!NkGL?Eirr8A]!!&ALrr`8JGQ*s/J,~>
+RK!NkGL?Eirr8A]!!&ALrr`8JGQ*s/J,~>
+R/[O7s8W)u8cSiVl2P>n!!)BKrr=(*s*t~>
+R/[O7s8W)u8cSiVl2P>n!!)BKrr=(*s*t~>
+R/[O7s8W)u8cSiVl2P>n!!)BKrr=(*s*t~>
+Rf<irGKBg`s#9uY49,<[pAFskQKS8LaERWNs*t~>
+Rf<irGKBg`s#9uY49,<[pAFskQKS8LaERWNs*t~>
+Rf<irGKBg`s#9uY49,<[pAFskQKS8LaERWNs*t~>
+RK!7.rr2t"rVuuprr2rr!!%Z6rr=+,s*t~>
+RK!7.rr2t"rVuuprr2rr!!%Z6rr=+,s*t~>
+RK!7.rr2t"rVuuprr2rr!!%Z6rr=+,s*t~>
+Rf<N3DZBa3rVuqCrVllcr;Zi(k5PI"aI*!X~>
+Rf<N3DZBa3rVuqCrVllcr;Zi(k5PI"aI*!X~>
+Rf<N3DZBa3rVuqCrVllcr;Zi(k5PI"aI*!X~>
+Rf<I1s8Mim!!)-[rrN+krVup-jSo3#R/_[~>
+Rf<I1s8Mim!!)-[rrN+krVup-jSo3#R/_[~>
+Rf<I1s8Mim!!)-[rrN+krVup-jSo3#R/_[~>
+Rf<J7rr6d5!!!c5rrW3"'`J(5c2Ql*!WI>2s*t~>
+Rf<J7rr6d5!!!c5rrW3"'`J(5c2Ql*!WI>2s*t~>
+Rf<J7rr6d5!!!c5rrW3"'`J(5c2Ql*!WI>2s*t~>
+S,WT3DZBb8!!Ppns8N$drVur:j8T-taI3'Y~>
+S,WT3DZBb8!!Ppns8N$drVur:j8T-taI3'Y~>
+S,WT3DZBb8!!Ppns8N$drVur:j8T-taI3'Y~>
+S,WS.s8Jno!!mB?s4\h"!'K`/rr?r)s*t~>
+S,WS.s8Jno!!mB?s4\h"!'K`/rr?r)s*t~>
+S,WS.s8Jno!!mB?s4\h"!'K`/rr?r)s*t~>
+SGr`kGlReHr;[+JZU4]m1W'1kiVrq'rgNk;~>
+SGr`kGlReHr;[+JZU4]m1W'1kiVrq'rgNk;~>
+SGr`kGlReHr;[+JZU4]m1W'1kiVrq'rgNk;~>
+S,WR3s8O;?!!EI>g].91rr=+.s*t~>
+S,WR3s8O;?!!EI>g].91rr=+.s*t~>
+S,WR3s8O;?!!EI>g].91rr=+.s*t~>
+S,WP.s8Vus"<P\bs8Mio!9!#>!,n;*J,~>
+S,WP.s8Vus"<P\bs8Mio!9!#>!,n;*J,~>
+S,WP.s8Vus"<P\bs8Mio!9!#>!,n;*J,~>
+S,WP.s8VrrpAY/MG38f)DjgWU~>
+S,WP.s8VrrpAY/MG38f)DjgWU~>
+S,WP.s8VrrpAY/MG38f)DjgWU~>
+S,WP.s8Vrr!OMe&rri?$KE-Marr?u*s*t~>
+S,WP.s8Vrr!OMe&rri?$KE-Marr?u*s*t~>
+S,WP.s8Vrr!OMe&rri?$KE-Marr?u*s*t~>
+S,WS/s8O):!!4#;rr)j#rr6^5!28QT!,n;*J,~>
+S,WS/s8O):!!4#;rr)j#rr6^5!28QT!,n;*J,~>
+S,WS/s8O):!!4#;rr)j#rr6^5!28QT!,n;*J,~>
+S,WS/s8QO)!!+tRrVm#_1]RN<r;Qp!s,n&=n,EB+RK%d~>
+S,WS/s8QO)!!+tRrVm#_1]RN<r;Qp!s,n&=n,EB+RK%d~>
+S,WS/s8QO)!!+tRrVm#_1]RN<r;Qp!s,n&=n,EB+RK%d~>
+S,WS8rr1FC!!>u@E]<st!3c>#"TIp='(kYm!WI>3s*t~>
+S,WS8rr1FC!!>u@E]<st!3c>#"TIp='(kYm!WI>3s*t~>
+S,WS8rr1FC!!>u@E]<st!3c>#"TIp='(kYm!WI>3s*t~>
+S,WI0rr2t!o`,"#eboFNrp^BsmJcPR!$7R.J,~>
+S,WI0rr2t!o`,"#eboFNrp^BsmJcPR!$7R.J,~>
+S,WI0rr2t!o`,"#eboFNrp^BsmJcPR!$7R.J,~>
+S,WY1s8W)u1%tYL;#C7hrrODFOR2uIDjgWU~>
+S,WY1s8W)u1%tYL;#C7hrrODFOR2uIDjgWU~>
+S,WY1s8W)u1%tYL;#C7hrrODFOR2uIDjgWU~>
+S,W\1aT);>s*skF"$k'0rql]sN;s:OrrL2YRK%d~>
+S,W\1aT);>s*skF"$k'0rql]sN;s:OrrL2YRK%d~>
+S,W\1aT);>s*skF"$k'0rql]sN;s:OrrL2YRK%d~>
+Rf<A*qu6o5NId2&qZ$QjrrrZ-I)6-hRIL4VDOCHS~>
+Rf<A*qu6o5NId2&qZ$QjrrrZ-I)6-hRIL4VDOCHS~>
+Rf<A*qu6o5NId2&qZ$QjrrrZ-I)6-hRIL4VDOCHS~>
+Rf<@/m/I@4!!(r[qAB:bnc&S1R/_[~>
+Rf<@/m/I@4!!(r[qAB:bnc&S1R/_[~>
+Rf<@/m/I@4!!(r[qAB:bnc&S1R/_[~>
+S,WQhGKB1O!g<Terr3%G!/:"D!m#TbRK%d~>
+S,WQhGKB1O!g<Terr3%G!/:"D!m#TbRK%d~>
+S,WQhGKB1O!g<Terr3%G!/:"D!m#TbRK%d~>
+RK!;3rpKdfJcJ1;rrQU/Q1P"Vrca_/J,~>
+RK!;3rpKdfJcJ1;rrQU/Q1P"Vrca_/J,~>
+RK!;3rpKdfJcJ1;rrQU/Q1P"Vrca_/J,~>
+T)Sf*rdP!)!.aM;!git,rr3$5!:9:V!<@S9s*t~>
+T)Sf*rdP!)!.aM;!git,rr3$5!:9:V!<@S9s*t~>
+T)Sf*rdP!)!.aM;!git,rr3$5!:9:V!<@S9s*t~>
+T)Se7qZ-'a#O2;5s8K_4J+N[Crc^R-/XcWh~>
+T)Se7qZ-'a#O2;5s8K_4J+N[Crc^R-/XcWh~>
+T)Se7qZ-'a#O2;5s8K_4J+N[Crc^R-/XcWh~>
+RfE?emJd?A#P6s[JaraC*WI\l/Xl]i~>
+RfE?emJd?A#P6s[JaraC*WI\l/Xl]i~>
+RfE?emJd?A#P6s[JaraC*WI\l/Xl]i~>
+S,WUC!<<-HmJd:4G`D1^rrsLcs8OYO/Xucj~>
+S,WUC!<<-HmJd:4G`D1^rrsLcs8OYO/Xucj~>
+S,WUC!<<-HmJd:4G`D1^rrsLcs8OYO/Xucj~>
+SGrgG!A0B5LXH+Wrr`8JGQ.UA!\FF)SH"*~>
+SGrgG!A0B5LXH+Wrr`8JGQ.UA!\FF)SH"*~>
+SGrgG!A0B5LXH+Wrr`8JGQ.UA!\FF)SH"*~>
+Sc8sJ!A4>$!<4%\h>[Mt*;fa;/HIGos*t~>
+Sc8sJ!A4>$!<4%\h>[Mt*;fa;/HIGos*t~>
+Sc8sJ!A4>$!<4%\h>[Mt*;fa;/HIGos*t~>
+TDo8tci?!(s*"JCruBkp!$(h7!\FF)T)X<~>
+TDo8tci?!(s*"JCruBkp!$(h7!\FF)T)X<~>
+TDo8tci?!(s*"JCruBkp!$(h7!\FF)T)X<~>
+T`5/od/X0frVuos!R_tFrrO1grqZQq/HIGqs*t~>
+T`5/od/X0frVuos!R_tFrrO1grqZQq/HIGqs*t~>
+T`5/od/X0frVuos!R_tFrrO1grqZQq/HIGqs*t~>
+U&P;qd/X0orql]urmDedroO._rr3tdrqHEo/HIGrs*t~>
+U&P;qd/X0orql]urmDedroO._rr3tdrqHEo/HIGrs*t~>
+U&P;qd/X0orql]urmDedroO._rr3tdrqHEo/HIGrs*t~>
+T`>#l!R^oBrri>C*7FiLrri>L*6J3QrrObQ/YW2p~>
+T`>#l!R^oBrri>C*7FiLrri>L*6J3QrrObQ/YW2p~>
+T`>#l!R^oBrri>C*7FiLrri>L*6J3QrrObQ/YW2p~>
+U&P3H!It+ArrF+ekPkS1*:a%1/HIGts*t~>
+U&P3H!It+ArrF+ekPkS1*:a%1/HIGts*t~>
+U&P3H!It+ArrF+ekPkS1*:a%1/HIGts*t~>
+UAk9H!A3mB!d>[+li.%-*I$uP!\FF)U]5i~>
+UAk9H!A3mB!d>[+li.%-*I$uP!\FF)U]5i~>
+UAk9H!A3mB!d>[+li.%-*I$uP!\FF)U]5i~>
+U]1BJ!A3jA"TJFF*Q[^L"NVU-s8MHd!\FF)V#Pr~>
+U]1BJ!A3jA"TJFF*Q[^L"NVU-s8MHd!\FF)V#Pr~>
+U]1BJ!A3jA"TJFF*Q[^L"NVU-s8MHd!\FF)V#Pr~>
+V>gYsci>ulrri?$G91Ynrrd3\GQ7[.rrObQ/Z&Jt~>
+V>gYsci>ulrri?$G91Ynrrd3\GQ7[.rrObQ/Z&Jt~>
+V>gYsci>ulrri?$G91Ynrrd3\GQ7[.rrObQ/Z&Jt~>
+VZ-eud/X0fm/I:hs2]C*Df5IP#&\?#GKBg`kl1]9!A12KJ,~>
+VZ-eud/X0fm/I:hs2]C*Df5IP#&\?#GKBg`kl1]9!A12KJ,~>
+VZ-eud/X0fm/I:hs2]C*Df5IP#&\?#GKBg`kl1]9!A12KJ,~>
+VuHr"d/X0orosFlrr<#>/c^*6Df3Yrs8M*Z!\FF)VuM8~>
+VuHr"d/X0orosFlrr<#>/c^*6Df3Yrs8M*Z!\FF)VuM8~>
+VuHr"d/X0orosFlrr<#>/c^*6Df3Yrs8M*Z!\FF)VuM8~>
+VZ6Yr!R^o-rrITLg]%=,!A18MJ,~>
+VZ6Yr!R^o-rrITLg]%=,!A18MJ,~>
+VZ6Yr!R^o-rrITLg]%=,!A18MJ,~>
+VuHiN!It+/rrITLgA_4+!A1;NJ,~>
+VuHiN!It+/rrITLgA_4+!A1;NJ,~>
+VuHiN!It+/rrITLgA_4+!A1;NJ,~>
+W;coN!A3:1!Ik+&rrObQ/ZSi$~>
+W;coN!A3:1!Ik+&rrObQ/ZSi$~>
+W;coN!A3:1!Ik+&rrObQ/ZSi$~>
+WW*#P!A370!Ik+%rrObQ/Z\o%~>
+WW*#P!A370!Ik+%rrObQ/Z\o%~>
+WW*#P!A370!Ik+%rrObQ/Z\o%~>
+X8`;$ci>u]rrITLfDbn(!A1DQJ,~>
+X8`;$ci>u]rrITLfDbn(!A1DQJ,~>
+X8`;$ci>u]rrITLfDbn(!A1DQJ,~>
+XT&G&d/X0fhu<_,!7q/O/HIH*s*t~>
+XT&G&d/X0fhu<_,!7q/O/HIH*s*t~>
+XT&G&d/X0fhu<_,!7q/O/HIH*s*t~>
+XoAS(d/X0ornm_VIfS%!!\FF)Y5a"~>
+XoAS(d/X0ornm_VIfS%!!\FF)Y5a"~>
+XoAS(d/X0ornm_VIfS%!!\FF)Y5a"~>
+XT/;#!R^o'rrITLeGfS%!A1MTJ,~>
+XT/;#!R^o'rrITLeGfS%!A1MTJ,~>
+XT/;#!R^o'rrITLeGfS%!A1MTJ,~>
+XoAJT!It+)rrITLe,KJ$!A1PUJ,~>
+XoAJT!It+)rrITLe,KJ$!A1PUJ,~>
+XoAJT!It+)rrITLe,KJ$!A1PUJ,~>
+Y5\PT!A3(+!Ik*trrObQ/[>>+~>
+Y5\PT!A3(+!Ik*trrObQ/[>>+~>
+Y5\PT!A3(+!Ik*trrObQ/[>>+~>
+YQ"YV!A3%*!Ik*srrObQ/[GD,~>
+YQ"YV!A3%*!Ik*srrObQ/[GD,~>
+YQ"YV!A3%*!Ik*srrObQ/[GD,~>
+Z2Xq*ci>uWrrITLd/O/!!A1YXJ,~>
+Z2Xq*ci>uWrrITLd/O/!!A1YXJ,~>
+Z2Xq*ci>uWrrITLd/O/!!A1YXJ,~>
+ZMt(,d/X0fg&D)&!71ZH/HIH1s*t~>
+ZMt(,d/X0fg&D)&!71ZH/HIH1s*t~>
+ZMt(,d/X0fg&D)&!71ZH/HIH1s*t~>
+Zi:4.d/X0orn7;PIfRdo!\FF)[Jta~>
+Zi:4.d/X0orn7;PIfRdo!\FF)[Jta~>
+Zi:4.d/X0orn7;PIfRdo!\FF)[Jta~>
+ZN'q)!R^o!rrITLc2Rhs!A4<N!P`ijs*t~>
+ZN'q)!R^o!rrITLc2Rhs!A4<N!P`ijs*t~>
+ZN'q)!R^o!rrITLc2Rhs!A4<N!P`ijs*t~>
+Zi:+Z!It+#rrITLbl7l!!A4?OIfR+\J,~>
+Zi:+Z!It+#rrITLbl7l!!A4?OIfR+\J,~>
+Zi:+Z!It+#rrITLbl7l!!A4?OIfR+\J,~>
+[/U1Z!A2k%!Ik*mrrjtT/cU;#]DmB~>
+[/U1Z!A2k%!Ik*mrrjtT/cU;#]DmB~>
+[/U1Z!A2k%!Ik*mrrjtT/cU;#]DmB~>
+`W#r;qYpQpqYpUL!A2h$!Ik*lrranS/W]tEs*t~>
+`W#r;qYpQpqYpUL!A2h$!Ik*lrranS/W]tEs*t~>
+`W#r;qYpQpqYpUL!A2h$!Ik*lrranS/W]tEs*t~>
+ao;PDs2])&*rKp`*dDSDs8N&tci>uQrrITLao;Gp!<<,3s*t~>
+ao;PDs2])&*rKp`*dDSDs8N&tci>uQrrITLao;Gp!<<,3s*t~>
+ao;PDs2])&*rKp`*dDSDs8N&tci>uQrrITLao;Gp!<<,3s*t~>
+b5VRbG91Yqrs*E_GKA,2!6EXh!Ik*nrr^#cIusX0]DmB~>
+b5VRbG91Yqrs*E_GKA,2!6EXh!Ik*nrr^#cIusX0]DmB~>
+b5VRbG91Yqrs*E_GKA,2!6EXh!Ik*nrr^#cIusX0]DmB~>
+bl7ac*I%#Q"EshGg&BJ#!Ik*nrr@9?!5&8]~>
+bl7ac*I%#Q"EshGg&BJ#!Ik*nrr@9?!5&8]~>
+bl7ac*I%#Q"EshGg&BJ#!Ik*nrr@9?!5&8]~>
+cMn$g*I%P_nG`Xjs*u*1e,KGu!6G0BIXa"prGMd_*cGr7s*t~>
+cMn$g*I%P_nG`Xjs*u*1e,KGu!6G0BIXa"prGMd_*cGr7s*t~>
+cMn$g*I%P_nG`Xjs*u*1e,KGu!6G0BIXa"prGMd_*cGr7s*t~>
+ci4(fGQ7[/rr`9#G9,35!Ik*ors8W(DB=#Cs8W)srs8W(s2]C*DZB^Xs*t~>
+ci4(fGQ7[/rr`9#G9,35!Ik*ors8W(DB=#Cs8W)srs8W(s2]C*DZB^Xs*t~>
+ci4(fGQ7[/rr`9#G9,35!Ik*ors8W(DB=#Cs8W)srs8W(s2]C*DZB^Xs*t~>
+df0ILruBJdkl1ebdN&;dfDbl$!71ZLrr70_aT)84rs&K&a;oL)rlb=l~>
+df0ILruBJdkl1ebdN&;dfDbl$!71ZLrr70_aT)84rs&K&a;oL)rlb=l~>
+df0ILruBJdkl1ebdN&;dfDbl$!71ZLrr70_aT)84rs&K&a;oL)rlb=l~>
+e,KRMdN$C.k5PS`aW/b.f`(u%!8IMS^NTGQ"TJFF*Q[XJ"NVU-s8L:CJ,~>
+e,KRMdN$C.k5PS`aW/b.f`(u%!8IMS^NTGQ"TJFF*Q[XJ"NVU-s8L:CJ,~>
+e,KRMdN$C.k5PS`aW/b.f`(u%!8IMS^NTGQ"TJFF*Q[XJ"NVU-s8L:CJ,~>
+eGfULdN%3F!Z]Yfg&D)&!8IMTFoa2lrr`8K*6@CE"3;J1rm(Oo~>
+eGfULdN%3F!Z]Yfg&D)&!8IMTFoa2lrr`8K*6@CE"3;J1rm(Oo~>
+eGfULdN%3F!Z]Yfg&D)&!8IMTFoa2lrr`8K*6@CE"3;J1rm(Oo~>
+eGfQk*8^\r*6Hn6!Ik+'rrObQ/c>VLd2_9J!?BM4s*t~>
+eGfQk*8^\r*6Hn6!Ik+'rrObQ/c>VLd2_9J!?BM4s*t~>
+eGfQk*8^\r*6Hn6!Ik+'rrObQ/c>VLd2_9J!?BM4s*t~>
+eGfLgh#@?og&D)&!87AR/HII&rrF-aj8T.(*RFb9~>
+eGfLgh#@?og&D)&!87AR/HII&rrF-aj8T.(*RFb9~>
+eGfLgh#@?og&D)&!87AR/HII&rrF-aj8T.(*RFb9~>
+ec,[kdf07G!<2!X!rgUggA_2'!8.;U/HII'*7FiHrrW2J*74_9~>
+ec,[kdf07G!<2!X!rgUggA_2'!8.;U/HII'*7FiHrrW2J*74_9~>
+ec,[kdf07G!<2!X!rgUggA_2'!8.;U/HII'*7FiHrrW2J*74_9~>
+fDcE]d<GTis8N&A?5W_C+++%el2LhaJ;;m/!^?[?fma!`rVuuHro*kYrmDh7s*t~>
+fDcE]d<GTis8N&A?5W_C+++%el2LhaJ;;m/!^?[?fma!`rVuuHro*kYrmDh7s*t~>
+fDcE]d<GTis8N&A?5W_C+++%el2LhaJ;;m/!^?[?fma!`rVuuHro*kYrmDh7s*t~>
+f)G^irVlod3r/gX(&7dmrr@5C!8d_Xrccche,Op~>
+f)G^irVlod3r/gX(&7dmrr@5C!8d_Xrccche,Op~>
+f)G^irVlod3r/gX(&7dmrr@5C!8d_Xrccche,Op~>
+f`)$PGKBd`!6Y9@"/l1U"TAB$?K_=hIYceZ!J^[-rrh9\!7CfErs$N-JsFsfroj@_*6H\0J,~>
+f`)$PGKBd`!6Y9@"/l1U"TAB$?K_=hIYceZ!J^[-rrh9\!7CfErs$N-JsFsfroj@_*6H\0J,~>
+f`)$PGKBd`!6Y9@"/l1U"TAB$?K_=hIYceZ!J^[-rrh9\!7CfErs$N-JsFsfroj@_*6H\0J,~>
+fDbgkrr2u<rVurCrr2t2rVup&k5PE%h#@D)!8@G[rm:]GdJj1Fs*XtH!!5"Mroj@^*7Oq<~>
+fDbgkrr2u<rVurCrr2t2rVup&k5PE%h#@D)!8@G[rm:]GdJj1Fs*XtH!!5"Mroj@^*7Oq<~>
+fDbgkrr2u<rVurCrr2t2rVup&k5PE%h#@D)!8@G[rm:]GdJj1Fs*XtH!!5"Mroj@^*7Oq<~>
+f`)(laT)8!rVuq>rVlkEr;c![!Q]07rrITLg]%c_d/X0nrr<#O%KHK2GROKN!$CG)"9-\lrmh%!~>
+f`)(laT)8!rVuq>rVlkEr;c![!Q]07rrITLg]%c_d/X0nrr<#O%KHK2GROKN!$CG)"9-\lrmh%!~>
+f`)(laT)8!rVuq>rVlkEr;c![!Q]07rrITLg]%c_d/X0nrr<#O%KHK2GROKN!$CG)"9-\lrmh%!~>
+f`)'qs8N$5rVurrrVlk)rVupCjo5<%h>[M*!8IMUa8c3!rr2u8rW!&Js8U=A!!'Ijrr=(hs*t~>
+f`)'qs8N$5rVurrrVlk)rVupCjo5<%h>[M*!8IMUa8c3!rr2u8rW!&Js8U=A!!'Ijrr=(hs*t~>
+f`)'qs8N$5rVurrrVlk)rVupCjo5<%h>[M*!8IMUa8c3!rr2u8rW!&Js8U=A!!'Ijrr=(hs*t~>
+g&D2rGQ.VdrVuptr;Qa-rVuqdk5PM^GKAY@!Ik+(rs!ZI8]Ul1d/F"FX8W(s!!%c:rrU8crmq+"~>
+g&D2rGQ.VdrVuptr;Qa-rVuqdk5PM^GKAY@!Ik+(rs!ZI8]Ul1d/F"FX8W(s!!%c:rrU8crmq+"~>
+g&D2rGQ.VdrVuptr;Qa-rVuqdk5PM^GKAY@!Ik+(rs!ZI8]Ul1d/F"FX8W(s!!%c:rrU8crmq+"~>
+g&D.ls8Vcj!!/trrr2tjrVup[j8T*shZ!V+!87AW*WQ-2"98ESr;Z]q!0cRF!$9\jJ,~>
+g&D.ls8Vcj!!/trrr2tjrVup[j8T*shZ!V+!87AW*WQ-2"98ESr;Z]q!0cRF!$9\jJ,~>
+g&D.ls8Vcj!!/trrr2tjrVup[j8T*shZ!V+!87AW*WQ-2"98ESr;Z]q!0cRF!$9\jJ,~>
+g&D-qs8RKF!!([NrrC=C!!5UhroF(Z*o?ntIfS4&"NYK\s#p>]"h"@0s8L=B!!)-CrrI#Yf)L7~>
+g&D-qs8RKF!!([NrrC=C!!5UhroF(Z*o?ntIfS4&"NYK\s#p>]"h"@0s8L=B!!)-CrrI#Yf)L7~>
+g&D-qs8RKF!!([NrrC=C!!5UhroF(Z*o?ntIfS4&"NYK\s#p>]"h"@0s8L=B!!)-CrrI#Yf)L7~>
+g&D/!rr3`3!!E)ts+L@O!h0/gjSo8[Gi&H$IfS4&"!.F@\GZF*rr?F*!!$Berr=(js*t~>
+g&D/!rr3`3!!E)ts+L@O!h0/gjSo8[Gi&H$IfS4&"!.F@\GZF*rr?F*!!$Berr=(js*t~>
+g&D/!rr3`3!!E)ts+L@O!h0/gjSo8[Gi&H$IfS4&"!.F@\GZF*rr?F*!!$Berr=(js*t~>
+g&D+ks69F]#4-jF!!%9Bi;Wdpj8T.pG5hLGIfTNKrlB<@rr[NFs!RdG!&4BO!6>'=!]C#Wk5PJ]
+Gh2nF~>
+g&D+ks69F]#4-jF!!%9Bi;Wdpj8T.pG5hLGIfTNKrlB<@rr[NFs!RdG!&4BO!6>'=!]C#Wk5PJ]
+Gh2nF~>
+g&D+ks69F]#4-jF!!%9Bi;Wdpj8T.pG5hLGIfTNKrlB<@rr[NFs!RdG!&4BO!6>'=!]C#Wk5PJ]
+Gh2nF~>
+gA_7maT&OA!!+sLh>[MsDWLg*Foa2ps*k%Krm:]Gi;Wo#DZA>e!!HX.rr9D*!!6p8roF([DTLH0
+J,~>
+gA_7maT&OA!!+sLh>[MsDWLg*Foa2ps*k%Krm:]Gi;Wo#DZA>e!!HX.rr9D*!!6p8roF([DTLH0
+J,~>
+gA_7maT&OA!!+sLh>[MsDWLg*Foa2ps*k%Krm:]Gi;Wo#DZA>e!!HX.rr9D*!!6p8roF([DTLH0
+J,~>
+gA_7ns8S/X!!@]Bs8Mlp!WM3Brr?utrsLCZ/cU;#s3UfHdJi,)")e/=I/O$OErXZ[!!"V!s8M$X
+!,gEgJ,~>
+gA_7ns8S/X!!@]Bs8Mlp!WM3Brr?utrsLCZ/cU;#s3UfHdJi,)")e/=I/O$OErXZ[!!"V!s8M$X
+!,gEgJ,~>
+gA_7ns8S/X!!@]Bs8Mlp!WM3Brr?utrsLCZ/cU;#s3UfHdJi,)")e/=I/O$OErXZ[!!"V!s8M$X
+!,gEgJ,~>
+gA_7ns8RZJ!!&#RrrW2m!p0F^DrUd'/HIGb!9!nXdJi,)"TEZGs#U)Y#;mY)!(b-0ro!eWGlH@q
+J,~>
+gA_7ns8RZJ!!&#RrrW2m!p0F^DrUd'/HIGb!9!nXdJi,)"TEZGs#U)Y#;mY)!(b-0ro!eWGlH@q
+J,~>
+gA_7ns8RZJ!!&#RrrW2m!p0F^DrUd'/HIGb!9!nXdJi,)"TEZGs#U)Y#;mY)!(b-0ro!eWGlH@q
+J,~>
+gA_7ns8RoQ!!"/;rr`8j&ch%n!,pir!A+?N!!1LHhu<d"s8NT,!!G0Cp](6irrE&[rr=+ls*t~>
+gA_7ns8RoQ!!"/;rr`8j&ch%n!,pir!A+?N!!1LHhu<d"s8NT,!!G0Cp](6irrE&[rr=+ls*t~>
+gA_7ns8RoQ!!"/;rr`8j&ch%n!,pir!A+?N!!1LHhu<d"s8NT,!!G0Cp](6irrE&[rr=+ls*t~>
+gA_7ns8T1t!!&birr_0d!=\l*"9/%V^[M1&DrCWq/cG_MiVriWro*kYDu]k8!!"GArrW2lPNMlF
+DqG#>~>
+gA_7ns8T1t!!&birr_0d!=\l*"9/%V^[M1&DrCWq/cG_MiVriWro*kYDu]k8!!"GArrW2lPNMlF
+DqG#>~>
+gA_7ns8T1t!!&birr_0d!=\l*"9/%V^[M1&DrCWq/cG_MiVriWro*kYDu]k8!!"GArrW2lPNMlF
+DqG#>~>
+gA_7ns8VZd!!'(trrn\g!#P>-rVm'#h$!eHrp]pfDrgp0rr:&WJ,fS+DJsG7G](V&roO.]Du]k7
+!!2KdqYpZsoFc]:rr?uhs*t~>
+gA_7ns8VZd!!'(trrn\g!#P>-rVm'#h$!eHrp]pfDrgp0rr:&WJ,fS+DJsG7G](V&roO.]Du]k7
+!!2KdqYpZsoFc]:rr?uhs*t~>
+gA_7ns8VZd!!'(trrn\g!#P>-rVm'#h$!eHrp]pfDrgp0rr:&WJ,fS+DJsG7G](V&roO.]Du]k7
+!!2KdqYpZsoFc]:rr?uhs*t~>
+gA_.jrr2s`q>^gCBmX+k!!"_Orr)j#rnDMt!9N\L"`FA>s)u0Brr^>d*cCrV!<2lq")]0(aQEL)
+Du]hAqu?_3qYp]tlOO#Br;Qlus1!RIrr?uhs*t~>
+gA_.jrr2s`q>^gCBmX+k!!"_Orr)j#rnDMt!9N\L"`FA>s)u0Brr^>d*cCrV!<2lq")]0(aQEL)
+Du]hAqu?_3qYp]tlOO#Br;Qlus1!RIrr?uhs*t~>
+gA_.jrr2s`q>^gCBmX+k!!"_Orr)j#rnDMt!9N\L"`FA>s)u0Brr^>d*cCrV!<2lq")]0(aQEL)
+Du]hAqu?_3qYp]tlOO#Br;Qlus1!RIrr?uhs*t~>
+gA_;sDZB^roDer(s8Mus"odt+f`2HLrs!A^s3L`HG3o51a;oKorrRBbaQWX+Du]huqZ%#=s8N&u
+rr:%A!#+burri?$8H9Xsrr?uhs*t~>
+gA_;sDZB^roDer(s8Mus"odt+f`2HLrs!A^s3L`HG3o51a;oKorrRBbaQWX+Du]huqZ%#=s8N&u
+rr:%A!#+burri?$8H9Xsrr?uhs*t~>
+gA_;sDZB^roDer(s8Mus"odt+f`2HLrs!A^s3L`HG3o51a;oKorrRBbaQWX+Du]huqZ%#=s8N&u
+rr:%A!#+burri?$8H9Xsrr?uhs*t~>
+g&D%jrr2u1pAb:"[f?@*rs&K&>5s*Q>OVRqDV-lJ!.XD9"NVU-s8MNf"TJFF*Q[OG")n5>PPP7d
+ES^ZpaA`->+o)'9rrrE%0j4Qfn,EB+fDg@~>
+g&D%jrr2u1pAb:"[f?@*rs&K&>5s*Q>OVRqDV-lJ!.XD9"NVU-s8MNf"TJFF*Q[OG")n5>PPP7d
+ES^ZpaA`->+o)'9rrrE%0j4Qfn,EB+fDg@~>
+g&D%jrr2u1pAb:"[f?@*rs&K&>5s*Q>OVRqDV-lJ!.XD9"NVU-s8MNf"TJFF*Q[OG")n5>PPP7d
+ES^ZpaA`->+o)'9rrrE%0j4Qfn,EB+fDg@~>
+g&D$nrVloQ0Db_O%"SBWqYpb;rVnSPYQ"%k"YTiU8B:_trrX9cs8MBb"9/=E*UE_.GlIaC#P7ut
+6i[/`rrlH"5QItdnc&XhGh;tG~>
+g&D$nrVloQ0Db_O%"SBWqYpb;rVnSPYQ"%k"YTiU8B:_trrX9cs8MBb"9/=E*UE_.GlIaC#P7ut
+6i[/`rrlH"5QItdnc&XhGh;tG~>
+g&D$nrVloQ0Db_O%"SBWqYpb;rVnSPYQ"%k"YTiU8B:_trrX9cs8MBb"9/=E*UE_.GlIaC#P7ut
+6i[/`rrlH"5QItdnc&XhGh;tG~>
+gA_3QGl@XIrr;#OK8?2Pq#:QtZ-E:G!!)He"FrB1!7:68"TJE@df/J1"THghs8MQg#C"8h*rl9>
+a7TE6MZ<\QrreD_!!)i`rr=+ls*t~>
+gA_3QGl@XIrr;#OK8?2Pq#:QtZ-E:G!!)He"FrB1!7:68"TJE@df/J1"THghs8MQg#C"8h*rl9>
+a7TE6MZ<\QrreD_!!)i`rr=+ls*t~>
+gA_3QGl@XIrr;#OK8?2Pq#:QtZ-E:G!!)He"FrB1!7:68"TJE@df/J1"THghs8MQg#C"8h*rl9>
+a7TE6MZ<\QrreD_!!)i`rr=+ls*t~>
+g&D(jaR&p3N;rpZ!%l*Gnc&[3DL_Wc!\XNPo`#'ndN$C.k5PS`aW/b.o)J^i!Q]3XrrKt;q#CFR
+iV<ETrkSR[mf*9*fDg@~>
+g&D(jaR&p3N;rpZ!%l*Gnc&[3DL_Wc!\XNPo`#'ndN$C.k5PS`aW/b.o)J^i!Q]3XrrKt;q#CFR
+iV<ETrkSR[mf*9*fDg@~>
+g&D(jaR&p3N;rpZ!%l*Gnc&[3DL_Wc!\XNPo`#'ndN$C.k5PS`aW/b.o)J^i!Q]3XrrKt;q#CFR
+iV<ETrkSR[mf*9*fDg@~>
+f`(plmJd0\q>^L@nc&k8s*k%$2?<g)p&>*mdN%3F!Z]Yfo`#*oci>tRaSl,Gr.?O#!!+Qddf9=@
+rrR0?E:<f-aDTW0J,~>
+f`(plmJd0\q>^L@nc&k8s*k%$2?<g)p&>*mdN%3F!Z]Yfo`#*oci>tRaSl,Gr.?O#!!+Qddf9=@
+rrR0?E:<f-aDTW0J,~>
+f`(plmJd0\q>^L@nc&k8s*k%$2?<g)p&>*mdN%3F!Z]Yfo`#*oci>tRaSl,Gr.?O#!!+Qddf9=@
+rrR0?E:<f-aDTW0J,~>
+g&D*PGO>D9`.!2k!!%%ncLLoBGQ*'ls8RQK!&"<Nq#:B:*8^\r*6IdO""jUEG4kk8rq69n*!!VM
+nG`K+f)L7~>
+g&D*PGO>D9`.!2k!!%%ncLLoBGQ*'ls8RQK!&"<Nq#:B:*8^\r*6IdO""jUEG4kk8rq69n*!!VM
+nG`K+f)L7~>
+g&D*PGO>D9`.!2k!!%%ncLLoBGQ*'ls8RQK!&"<Nq#:B:*8^\r*6IdO""jUEG4kk8rq69n*!!VM
+nG`K+f)L7~>
+f`)#oGQ."0"9-:?%IjB,rccH`IfTNKrl?tu!7:N@!$(n9#02pZQ.Q'8l2L`'nc&YS!&s0B!pK[b
+mf*8.f)L7~>
+f`)#oGQ."0"9-:?%IjB,rccH`IfTNKrl?tu!7:N@!$(n9#02pZQ.Q'8l2L`'nc&YS!&s0B!pK[b
+mf*8.f)L7~>
+f`)#oGQ."0"9-:?%IjB,rccH`IfTNKrl?tu!7:N@!$(n9#02pZQ.Q'8l2L`'nc&YS!&s0B!pK[b
+mf*8.f)L7~>
+fDbgkli.#p!-Rc1"<IOBG6%R@"b-LP0)tqKrs'Rmrr;utI00<H!]9TLli.%cdN.u[!HpF$!!(()
+rrS2\..@0;aERX8s*t~>
+fDbgkli.#p!-Rc1"<IOBG6%R@"b-LP0)tqKrs'Rmrr;utI00<H!]9TLli.%cdN.u[!HpF$!!(()
+rrS2\..@0;aERX8s*t~>
+fDbgkli.#p!-Rc1"<IOBG6%R@"b-LP0)tqKrs'Rmrr;utI00<H!]9TLli.%cdN.u[!HpF$!!(()
+rrS2\..@0;aERX8s*t~>
+fDbonGQ."0!rs85rpp'jrccH^rrE&srrrDC2?<g)rr3E+d<GTis4Ik^!*FIRrVup?l2LkbGL?Ec
+rs<j-!!*'Y56-N=li.#A!-@Z0!WI;ns*t~>
+fDbonGQ."0!rs85rpp'jrccH^rrE&srrrDC2?<g)rr3E+d<GTis4Ik^!*FIRrVup?l2LkbGL?Ec
+rs<j-!!*'Y56-N=li.#A!-@Z0!WI;ns*t~>
+fDbonGQ."0!rs85rpp'jrccH^rrE&srrrDC2?<g)rr3E+d<GTis4Ik^!*FIRrVup?l2LkbGL?Ec
+rs<j-!!*'Y56-N=li.#A!-@Z0!WI;ns*t~>
+f)GakamT02rr<#tnc&X3*VB@:IfKI$s8N$<rr2u8rW!&Js8U=A!!'Ikrr=&9rsO!/!!*'YG5qSl
+!%mO:"S)Nm_Z'')!$0ViJ,~>
+f)GakamT02rr<#tnc&X3*VB@:IfKI$s8N$<rr2u8rW!&Js8U=A!!'Ikrr=&9rsO!/!!*'YG5qSl
+!%mO:"S)Nm_Z'')!$0ViJ,~>
+f)GakamT02rr<#tnc&X3*VB@:IfKI$s8N$<rr2u8rW!&Js8U=A!!'Ikrr=&9rsO!/!!*'YG5qSl
+!%mO:"S)Nm_Z'')!$0ViJ,~>
+ec,UhgA_-moD]0sa>O&!d!!M1rm:WE!3?(ur;ZhPkl2"2GQ7\d2ZNjY2g5-!"FgF(GQ."0!g*I2
+nG`RhGKA>7J,~>
+ec,UhgA_-moD]0sa>O&!d!!M1rm:WE!3?(ur;ZhPkl2"2GQ7\d2ZNjY2g5-!"FgF(GQ."0!g*I2
+nG`RhGKA>7J,~>
+ec,UhgA_-moD]0sa>O&!d!!M1rm:WE!3?(ur;ZhPkl2"2GQ7\d2ZNjY2g5-!"FgF(GQ."0!g*I2
+nG`RhGKA>7J,~>
+f)GgNdN.-C!Zf_gnc&T=rW!0&rq$<n!&"3Lr;Zh]kPk`55QCfb2g5#s"+L=N*U3S(rpg!ha8j`i
+J,~>
+f)GgNdN.-C!Zf_gnc&T=rW!0&rq$<n!&"3Lr;Zh]kPk`55QCfb2g5#s"+L=N*U3S(rpg!ha8j`i
+J,~>
+f)GgNdN.-C!Zf_gnc&T=rW!0&rq$<n!&"3Lr;Zh]kPk`55QCfb2g5#s"+L=N*U3S(rpg!ha8j`i
+J,~>
+ec,aNGL?EJrr`8JGQ.+3#6)\/!<<'^rW!,0rr<#tcM[_CjlcXGFoXIEpAY8>!<:.]g&D(3!7_%!~>
+ec,aNGL?EJrr`8JGQ.+3#6)\/!<<'^rW!,0rr<#tcM[_CjlcXGFoXIEpAY8>!<:.]g&D(3!7_%!~>
+ec,aNGL?EJrr`8JGQ.+3#6)\/!<<'^rW!,0rr<#tcM[_CjlcXGFoXIEpAY8>!<:.]g&D(3!7_%!~>
+e,KIhdf/8+!rgUfm/I/.s8BJ+!;uis?iC$*?fh:f-1_*9rW7;krn[SWrm:]HG1HVC~>
+e,KIhdf/8+!rgUfm/I/.s8BJ+!;uis?iC$*?fh:f-1_*9rW7;krn[SWrm:]HG1HVC~>
+e,KIhdf/8+!rgUfm/I/.s8BJ+!;uis?iC$*?fh:f-1_*9rW7;krn[SWrm:]HG1HVC~>
+df0=fdGk0,d2_NQ"NYfds!RdG!&4BO!6>'=!]C#WkPkV_GKB:R!?B5;rrgF`rr@Q!s*t~>
+df0=fdGk0,d2_NQ"NYfds!RdG!&4BO!6>'=!]C#WkPkV_GKB:R!?B5;rrgF`rr@Q!s*t~>
+df0=fdGk0,d2_NQ"NYfds!RdG!&4BO!6>'=!]C#WkPkV_GKB:R!?B5;rrgF`rr@Q!s*t~>
+dJj5k*T[5$*I$iL")e/=fDP[P?N:$)[Jg.-CB+:orr?s*rr=%prra>Arr>".s*t~>
+dJj5k*T[5$*I$iL")e/=fDP[P?N:$)[Jg.-CB+:orr?s*rr=%prra>Arr>".s*t~>
+dJj5k*T[5$*I$iL")e/=fDP[P?N:$)[Jg.-CB+:orr?s*rr=%prra>Arr>".s*t~>
+dJj@KdN&;dlMh"ds!6Y'li.&.s8RKF!"!]GeOKT>/^j[uj8T*#nG`RhdN%0E"WYtis#0r.s*t~>
+dJj@KdN&;dlMh"ds!6Y'li.&.s8RKF!"!]GeOKT>/^j[uj8T*#nG`RhdN%0E"WYtis#0r.s*t~>
+dJj@KdN&;dlMh"ds!6Y'li.&.s8RKF!"!]GeOKT>/^j[uj8T*#nG`RhdN%0E"WYtis#0r.s*t~>
+d/O:KaW5U*rpKdmrr70p!!(CGs8MHd"*jhF3rK$`2'Dr"8B1]/ir9&YGjkY8rmDedroO.crr3td
+rr<"J!7h+"~>
+d/O:KaW5U*rpKdmrr70p!!(CGs8MHd"*jhF3rK$`2'Dr"8B1]/ir9&YGjkY8rmDedroO.crr3td
+rr<"J!7h+"~>
+d/O:KaW5U*rpKdmrr70p!!(CGs8MHd"*jhF3rK$`2'Dr"8B1]/ir9&YGjkY8rmDedroO.crr3td
+rr<"J!7h+"~>
+c2Rpf*I%P_o)Amms*#L12Z*OULqiEY")e/=%f?;023[e7rql]qroX4\DXRN-rlH/.roa:armDe.
+rr2p!IfRO?s*t~>
+c2Rpf*I%P_o)Amms*#L12Z*OULqiEY")e/=%f?;023[e7rql]qroX4\DXRN-rlH/.roa:armDe.
+rr2p!IfRO?s*t~>
+c2Rpf*I%P_o)Amms*#L12Z*OULqiEY")e/=%f?;023[e7rql]qroX4\DXRN-rlH/.roa:armDe.
+rr2p!IfRO?s*t~>
+bPqae*I#U)rqQL(rr:&`*Q\9-!([(iO8o9)nG`T.aT);<!!"GArrW2lPNVrHaDUAE!?BMMrrLLe
+qu6`<!.WT"J,~>
+bPqae*I#U)rqQL(rr:&`*Q\9-!([(iO8o9)nG`T.aT);<!!"GArrW2lPNVrHaDUAE!?BMMrrLLe
+qu6`<!.WT"J,~>
+bPqae*I#U)rqQL(rr:&`*Q\9-!([(iO8o9)nG`T.aT);<!!"GArrW2lPNVrHaDUAE!?BMMrrLLe
+qu6`<!.WT"J,~>
+aSuB\*dDSDr;R8JDKm4?s8W)G!!(&q!64F+!,ql:qZ$ZarqcWsrq$hRk5PF"li.$1*Q[RH!luC+
+q>UKrM#Q$+J,~>
+aSuB\*dDSDr;R8JDKm4?s8W)G!!(&q!64F+!,ql:qZ$ZarqcWsrq$hRk5PF"li.$1*Q[RH!luC+
+q>UKrM#Q$+J,~>
+aSuB\*dDSDr;R8JDKm4?s8W)G!!(&q!64F+!,ql:qZ$ZarqcWsrq$hRk5PF"li.$1*Q[RH!luC+
+q>UKrM#Q$+J,~>
+`;^$ZDf.N7J8Y5`rr<5Mrl5"prpKddDuTb:#5eH$CARr5rp('qHKP5-DsRE,rr70_J9UM_"NVU-
+s8MiorrCXMJ,~>
+`;^$ZDf.N7J8Y5`rr<5Mrl5"prpKddDuTb:#5eH$CARr5rp('qHKP5-DsRE,rr70_J9UM_"NVU-
+s8MiorrCXMJ,~>
+`;^$ZDf.N7J8Y5`rr<5Mrl5"prpKddDuTb:#5eH$CARr5rp('qHKP5-DsRE,rr70_J9UM_"NVU-
+s8MiorrCXMJ,~>
+_uBl=d/X.uq>UYCaSu5>!!)Ed!,ql:!'9uW$bu`@s8W)ua9)DUmJd+iXb2_Zs7F>#rr@!%rri?$
+!!%36rrd3\GQ7[;rrW1U!7q1#~>
+_uBl=d/X.uq>UYCaSu5>!!)Ed!,ql:!'9uW$bu`@s8W)ua9)DUmJd+iXb2_Zs7F>#rr@!%rri?$
+!!%36rrd3\GQ7[;rrW1U!7q1#~>
+_uBl=d/X.uq>UYCaSu5>!!)Ed!,ql:!'9uW$bu`@s8W)ua9)DUmJd+iXb2_Zs7F>#rr@!%rri?$
+!!%36rrd3\GQ7[;rrW1U!7q1#~>
+`;]l;dJa+H!A4$F"9*cNG4,A1DuTb:PPP7gES^ZpaA`->+o)':rj;P&!7pZ>!,q-%#l];SI`Q^S
+Df5IP#&\?#GKBg`p&>)C!6<^kJ,~>
+`;]l;dJa+H!A4$F"9*cNG4,A1DuTb:PPP7gES^ZpaA`->+o)':rj;P&!7pZ>!,q-%#l];SI`Q^S
+Df5IP#&\?#GKBg`p&>)C!6<^kJ,~>
+`;]l;dJa+H!A4$F"9*cNG4,A1DuTb:PPP7gES^ZpaA`->+o)':rj;P&!7pZ>!,q-%#l];SI`Q^S
+Df5IP#&\?#GKBg`p&>)C!6<^kJ,~>
+`W#u<dJa+JO=^Jbp&>$m2t$\GDuK\9#P7ut6i[/brru8)F$Bs29^hu]Ds76$!<<'%rr<#>DZ+JV
+DTMkXrpp'j`rLV@s*t~>
+`W#u<dJa+JO=^Jbp&>$m2t$\GDuK\9#P7ut6i[/brru8)F$Bs29^hu]Ds76$!<<'%rr<#>DZ+JV
+DTMkXrpp'j`rLV@s*t~>
+`W#u<dJa+JO=^Jbp&>$m2t$\GDuK\9#P7ut6i[/brru8)F$Bs29^hu]Ds76$!<<'%rr<#>DZ+JV
+DTMkXrpp'j`rLV@s*t~>
+`r?DFd/X07!.Y##!A4$F!B1#Hrr?s9rrN,>o`,&Ns8Mus!*0!t!l!mtnG`K+l2Li<!It+.rrE+L
+fDg@~>
+`r?DFd/X07!.Y##!A4$F!B1#Hrr?s9rrN,>o`,&Ns8Mus!*0!t!l!mtnG`K+l2Li<!It+.rrE+L
+fDg@~>
+`r?DFd/X07!.Y##!A4$F!B1#Hrr?s9rrN,>o`,&Ns8Mus!*0!t!l!mtnG`K+l2Li<!It+.rrE+L
+fDg@~>
+`r?Ff!!(Dq!6>->/HIKurr[EFJ,\s;!Q]0WrrKt;q#CFRiVWWZrr;utrqq66rrI#YlMgq+!&id8
+!<>(1s*t~>
+`r?Ff!!(Dq!6>->/HIKurr[EFJ,\s;!Q]0WrrKt;q#CFRiVWWZrr;utrqq66rrI#YlMgq+!&id8
+!<>(1s*t~>
+`r?Ff!!(Dq!6>->/HIKurr[EFJ,\s;!Q]0WrrKt;q#CFRiVWWZrr;utrqq66rrI#YlMgq+!&id8
+!<>(1s*t~>
+`r?3d!7Cg*!<)ou/cbVFrrDKe!,qf8$N,N-!!!$LD:8I`pAY1Zs8MNf!,q-%!]L,"i;Wg:!8%7$~>
+`r?3d!7Cg*!<)ou/cbVFrrDKe!,qf8$N,N-!!!$LD:8I`pAY1Zs8MNf!,q-%!]L,"i;Wg:!8%7$~>
+`r?3d!7Cg*!<)ou/cbVFrrDKe!,qf8$N,N-!!!$LD:8I`pAY1Zs8MNf!,q-%!]L,"i;Wg:!8%7$~>
+`;]r=rr>"TrrE&nrr`7V!6=R.!$:e4!<2Zk!IBCdrr=,+rr`8I!&rg8!Ik+$s*t~>
+`;]r=rr>"TrrE&nrr`7V!6=R.!$:e4!<2Zk!IBCdrr=,+rr`8I!&rg8!Ik+$s*t~>
+`;]r=rr>"TrrE&nrr`7V!6=R.!$:e4!<2Zk!IBCdrr=,+rr`8I!&rg8!Ik+$s*t~>
+_Z'W:J+3I?`rLqpnc&XhGj550rk/=!rrIBDli6tb!6F't!d4Tff`-I~>
+_Z'W:J+3I?`rLqpnc&XhGj550rk/=!rrIBDli6tb!6F't!d4Tff`-I~>
+_Z'W:J+3I?`rLqpnc&XhGj550rk/=!rrIBDli6tb!6F't!d4Tff`-I~>
+_uBd]!I!r3rrDNf!H-!Err`8n!.OA9!Q]0Frri=N!It+*rrE+Lf`-I~>
+_uBd]!I!r3rrDNf!H-!Err`8n!.OA9!Q]0Frri=N!It+*rrE+Lf`-I~>
+_uBd]!I!r3rrDNf!H-!Err`8n!.OA9!Q]0Frri=N!It+*rrE+Lf`-I~>
+_uBae!:TpirdOrln,EA.lMgoU!;Q!^!$1A)rrCjS!<>(2s*t~>
+_uBae!:TpirdOrln,EA.lMgoU!;Q!^!$1A)rrCjS!<>(2s*t~>
+_uBae!:TpirdOrln,EA.lMgoU!;Q!^!$1A)rrCjS!<>(2s*t~>
+_uB`r!:Bde!&sEI!WI<0rr`8H!*&@c!I+P0rrXkSJ,\:(!B1#2s*t~>
+_uB`r!:Bde!&sEI!WI<0rr`8H!*&@c!I+P0rrXkSJ,\:(!B1#2s*t~>
+_uB`r!:Bde!&sEI!WI<0rr`8H!*&@c!I+P0rrXkSJ,\:(!B1#2s*t~>
+_uB`;2spVG2ZW=H!m#TbmJd8e!5&7"rrW1DaR&p.`rJ$PrrITLf`-I~>
+_uB`;2spVG2ZW=H!m#TbmJd8e!5&7"rrW1DaR&p.`rJ$PrrITLf`-I~>
+_uB`;2spVG2ZW=H!m#TbmJd8e!5&7"rrW1DaR&p.`rJ$PrrITLf`-I~>
+`;]nZ!.XD9"*O]prp]pf*UNe,!%716!$1D*!]L,"g]%>)!6<dmJ,~>
+`;]nZ!.XD9"*O]prp]pf*UNe,!%716!$1D*!]L,"g]%>)!6<dmJ,~>
+`;]nZ!.XD9"*O]prp]pf*UNe,!%716!$1D*!]L,"g]%>)!6<dmJ,~>
+`;]mg!6=I+rrDNf!m#Tbn,ELhs8W)frrW1DaR0!0rm1X(gA_5p!.W]%J,~>
+`;]mg!6=I+rrDNf!m#Tbn,ELhs8W)frrW1DaR0!0rm1X(gA_5p!.W]%J,~>
+`;]mg!6=I+rrDNf!m#Tbn,ELhs8W)frrW1DaR0!0rm1X(gA_5p!.W]%J,~>
+`W$#=L]HfA"9+)Va7'$/*Qd%8!QcAJs8N'!aP$Rp!/UX.s*t~>
+`W$#=L]HfA"9+)Va7'$/*Qd%8!QcAJs8N'!aP$Rp!/UX.s*t~>
+`W$#=L]HfA"9+)Va7'$/*Qd%8!QcAJs8N'!aP$Rp!/UX.s*t~>
+`;fi;li.(-!/UXCrr=%mrr=&*rri=N!It+%s8N)Ps*t~>
+`;fi;li.(-!/UXCrr=%mrr=&*rri=N!It+%s8N)Ps*t~>
+`;fi;li.(-!/UXCrr=%mrr=&*rri=N!It+%s8N)Ps*t~>
+`;]l=M#Q`?rrDNf!rgUgh#@Erdf/V5rrC^O!rduUg&HR~>
+`;]l=M#Q`?rrDNf!rgUgh#@Erdf/V5rrC^O!rduUg&HR~>
+`;]l=M#Q`?rrDNf!rgUgh#@Erdf/V5rrC^O!rduUg&HR~>
+`W$"[!.X>7"9*cNG45G5rccchi;WoYd<GTVrrXkSJ,\+#!e13jgAc[~>
+`W$"[!.X>7"9*cNG45G5rccchi;WoYd<GTVrrXkSJ,\+#!e13jgAc[~>
+`W$"[!.X>7"9*cNG45G5rccchi;WoYd<GTVrrXkSJ,\+#!e13jgAc[~>
+`W$!h!6=@(!<>(GrrO1gro3qZrmDePrrU4@2V.m0`rLVCs*t~>
+`W$!h!6=@(!<>(GrrO1gro3qZrmDePrrU4@2V.m0`rLVCs*t~>
+`W$!h!6=@(!<>(GrrO1gro3qZrmDePrrU4@2V.m0`rLVCs*t~>
+`W#rt!9jF`2ZWFK!5JJ^!g!E/ir9)-!0I//!-dr4!]L,"ec,XMJ(jpQ~>
+`W#rt!9jF`2ZWFK!5JJ^!g!E/ir9)-!0I//!-dr4!]L,"ec,XMJ(jpQ~>
+`W#rt!9jF`2ZWFK!5JJ^!g!E/ir9)-!0I//!-dr4!]L,"ec,XMJ(jpQ~>
+`W#r=2sC8DFod*lo`"o8qZ$YQ*T[5%*I!VB!:p-lrm1X(eGfOL2qn:^~>
+`W#r=2sC8DFod*lo`"o8qZ$YQ*T[5%*I!VB!:p-lrm1X(eGfOL2qn:^~>
+`W#r=2sC8DFod*lo`"o8qZ$YQ*T[5%*I!VB!:p-lrm1X(eGfOL2qn:^~>
+`W#r=J*6k3!:Tpm4obT_dN&;dlMh.hruBJdIfKI4rr2uto)J^i!6E[i!B1#4s*t~>
+`W#r=J*6k3!:Tpm4obT_dN&;dlMh.hruBJdIfKI4rr2uto)J^i!6E[i!B1#4s*t~>
+`W#r=J*6k3!:Tpm4obT_dN&;dlMh.hruBJdIfKI4rr2uto)J^i!6E[i!B1#4s*t~>
+`r?*`!I!],"9+)Va790:/HGhOs8L+\GQ7[1rseu-G9+g)s*k#4!B/$uoD\smIfY&ueGfQ!!8@I'~>
+`r?*`!I!],"9+)Va790:/HGhOs8L+\GQ7[1rseu-G9+g)s*k#4!B/$uoD\smIfY&ueGfQ!!8@I'~>
+`r?*`!I!],"9+)Va790:/HGhOs8L+\GQ7[1rseu-G9+g)s*k#4!B/$uoD\smIfY&ueGfQ!!8@I'~>
+`r?'h!9X:``rLqpoD\qG!A0B5rVm#A*I%P_o)Ajls*#L)rVm+P!<4YO!7Cf;s8N)IrrR?EG2*%I~>
+`r?'h!9X:``rLqpoD\qG!A0B5rVm#A*I%P_o)Ajls*#L)rVm+P!<4YO!7Cf;s8N)IrrR?EG2*%I~>
+`r?'h!9X:``rLqpoD\qG!A0B5rVm#A*I%P_o)Ajls*#L)rVm+P!<4YO!7Cf;s8N)IrrR?EG2*%I~>
+`r?&u!9O7\!;-9qrm1X's*k%Grs6[dGKBg`s1`dTrrrE%aEJZGqu6qO!<<)G!!(FGp&>+H!It*s
+rrE+Lg])d~>
+`r?&u!9O7\!;-9qrm1X's*k%Grs6[dGKBg`s1`dTrrrE%aEJZGqu6qO!<<)G!!(FGp&>+H!It*s
+rrE+Lg])d~>
+`r?&u!9O7\!;-9qrm1X's*k%Grs6[dGKBg`s1`dTrrrE%aEJZGqu6qO!<<)G!!(FGp&>+H!It*s
+rrE+Lg])d~>
+`r?&>2s1,BrdOrlpAYBsd/X0fs*"J<rrm9]G]#bHrVm#ADKm4?q#:YE!<<)ud/X0orqHEo`rJ$E
+rrE*Yg])d~>
+`r?&>2s1,BrdOrlpAYBsd/X0fs*"J<rrm9]G]#bHrVm#ADKm4?q#:YE!<<)ud/X0orqHEo`rJ$E
+rrE*Yg])d~>
+`r?&>2s1,BrdOrlpAYBsd/X0fs*"J<rrm9]G]#bHrVm#ADKm4?q#:YE!<<)ud/X0orqHEo`rJ$E
+rrE*Yg])d~>
+a8Z4]!.X)0!<>(PrrgCC!7CfFrrE&krrP(YG5cC[DY!f5rr<#td/X0orqQKp2ZUnFrrG%Yg])d~>
+a8Z4]!.X)0!<>(PrrgCC!7CfFrrE&krrP(YG5cC[DY!f5rr<#td/X0orqQKp2ZUnFrrG%Yg])d~>
+a8Z4]!.X)0!<>(PrrgCC!7CfFrrE&krrP(YG5cC[DY!f5rr<#td/X0orqQKp2ZUnFrrG%Yg])d~>
+a8Z3j!6=1#!B1#PrrY.Zd/NP7!Ik+6rri>K!!(CBrr`8I!&r7(!Ik+(s*t~>
+a8Z3j!6=1#!B1#PrrY.Zd/NP7!Ik+6rri>K!!(CBrr`8I!&r7(!Ik+(s*t~>
+a8Z3j!6=1#!B1#PrrY.Zd/NP7!Ik+6rri>K!!(CBrr`8I!&r7(!Ik+(s*t~>
+aSu>@L]HK8"*O]prqZQq/HIKlrrITLkl1ebd/X/!qZ$Qq!6ELd!e13jh#Dm~>
+aSu>@L]HK8"*O]prqZQq/HIKlrrITLkl1ebd/X/!qZ$Qq!6ELd!e13jh#Dm~>
+aSu>@L]HK8"*O]prqZQq/HIKlrrITLkl1ebd/X/!qZ$Qq!6ELd!e13jh#Dm~>
+a8c/>irB#Yq>ULK!A3^=!Ik+4rri>B2?>E.rri=N!It*prrU4@J)('S~>
+a8c/>irB#Yq>ULK!A3^=!Ik+4rri>B2?>E.rri=N!It*prrU4@J)('S~>
+a8c/>irB#Yq>ULK!A3^=!Ik+4rri>B2?>E.rri=N!It*prrU4@J)('S~>
+a8Z2@M#QK8"9+)Va8Gr>rm1X'm/I*9!9F.]/HII%s8N)CrrN1Vrn[U)~>
+a8Z2@M#QK8"9+)Va8Gr>rm1X'm/I*9!9F.]/HII%s8N)CrrN1Vrn[U)~>
+a8Z2@M#QK8"9+)Va8Gr>rm1X'm/I*9!9F.]/HII%s8N)CrrN1Vrn[U)~>
+aSu=^!.X#."31Ctrr2p#rm:]GaR&p-IfSO/#V?'/s8O\PJ,[^mrrCjSJ,~>
+aSu=^!.X#."31Ctrr2p#rm:]GaR&p-IfSO/#V?'/s8O\PJ,[^mrrCjSJ,~>
+aSu=^!.X#."31Ctrr2p#rm:]GaR&p-IfSO/#V?'/s8O\PJ,[^mrrCjSJ,~>
+aSu<k!6='urrE#t"NUQCdJiM4!Ik+/rrjtT/_C%]bl7bDL]H61J,~>
+aSu<k!6='urrE#t"NUQCdJiM4!Ik+/rrjtT/_C%]bl7bDL]H61J,~>
+aSu<k!6='urrE#t"NUQCdJiM4!Ik+/rrjtT/_C%]bl7bDL]H61J,~>
+aSu9"!9*q[rdOrlrr3'Y!7:`2rrITLiVs$4!<<,?bPqWn!6<pqJ,~>
+aSu9"!9*q[rdOrlrr3'Y!7:`2rrITLiVs$4!<<,?bPqWn!6<pqJ,~>
+aSu9"!9*q[rdOrlrr3'Y!7:`2rrITLiVs$4!<<,?bPqWn!6<pqJ,~>
+aSu8@2rFW>!&srX/HIKgrrITLi;WpE!!(CFbl7ab!.Wi)J,~>
+aSu8@2rFW>!&srX/HIKgrrITLi;WpE!!(CFbl7ab!.Wi)J,~>
+aSu8@2rFW>!&srX/HIKgrrITLi;WpE!!(CFbl7ab!.Wi)J,~>
+aSu8@J)C802ZWk1!A3O8!Ik+-s8;oudJhAi!<@W*s*t~>
+aSu8@J)C802ZWk1!A3O8!Ik+-s8;oudJhAi!<@W*s*t~>
+aSu8@J)C802ZWk1!A3O8!Ik+-s8;oudJhAi!<@W*s*t~>
+ao;Ec!I!B#"Ejf0!&j$?!Ik+/rs8UR!IiAq!7CejrrE*Yh>`!~>
+ao;Ec!I!B#"Ejf0!&j$?!Ik+/rs8UR!IiAq!7CejrrE*Yh>`!~>
+ao;Ec!I!B#"Ejf0!&j$?!Ik+/rs8UR!IiAq!7CejrrE*Yh>`!~>
+ao;Bk!8[\S!!(+'rrITLiW&oX#64\M!!(FGcMmo(!8[[*~>
+ao;Bk!8[\S!!(+'rrITLiW&oX#64\M!!(FGcMmo(!8[[*~>
+ao;Bk!8[\S!!(+'rrITLiW&oX#64\M!!(FGcMmo(!8[[*~>
+ao;B#!8d_Y`rH*qroa:^IfSL.#qc7.rr;uF!!(BkrrITLh>`!~>
+ao;B#!8d_Y`rH*qroa:^IfSL.#qc7.rr;uF!!(BkrrITLh>`!~>
+ao;B#!8d_Y`rH*qroa:^IfSL.#qc7.rr;uF!!(BkrrITLh>`!~>
+ao;AA2r=Q;2?3`5roa:^IfSO/!lk:!rVm$"d/X/!ci4&i!I!?"J,~>
+ao;AA2r=Q;2?3`5roa:^IfSO/!lk:!rVm$"d/X/!ci4&i!I!?"J,~>
+ao;AA2r=Q;2?3`5roa:^IfSO/!lk:!rVm$"d/X/!ci4&i!I!?"J,~>
+b5VO`!.Wo+">'X=!!)0]!Ik+0rrP+Za8Gr?rl?tu/^OFt!.Wl*J,~>
+b5VO`!.Wo+">'X=!!)0]!Ik+0rrP+Za8Gr?rl?tu/^OFt!.Wl*J,~>
+b5VO`!.Wo+">'X=!!)0]!Ik+0rrP+Za8Gr?rl?tu/^OFt!.Wl*J,~>
+b5VNm!6=$t"tfp.s*k&mkPkR4!9O4_rm1X(q#:CI!A2[u!<>(8s*t~>
+b5VNm!6=$t"tfp.s*k&mkPkR4!9O4_rm1X(q#:CI!A2[u!<>(8s*t~>
+b5VNm!6=$t"tfp.s*k&mkPkR4!9O4_rm1X(q#:CI!A2[u!<>(8s*t~>
+bPqYCL]HE6"9-XI2ZE^W!&s*@!Ik+1s8N'!aS5]9/HIHNrrG%YhZ&*~>
+bPqYCL]HE6"9-XI2ZE^W!&s*@!Ik+1s8N'!aS5]9/HIHNrrG%YhZ&*~>
+bPqYCL]HE6"9-XI2ZE^W!&s*@!Ik+1s8N'!aS5]9/HIHNrrG%YhZ&*~>
+b5_JAir9/\d/X0frr3!X!9a@_IfSX2"TElOJ,]0A!\FF)df0>t!8da+~>
+b5_JAir9/\d/X0frr3!X!9a@_IfSX2"TElOJ,]0A!\FF)df0>t!8da+~>
+b5_JAir9/\d/X0frr3!X!9a@_IfSX2"TElOJ,]0A!\FF)df0>t!8da+~>
+b5VMCM#QH7"NUQCdJj.F"*O]prosF`IfSU1rrDZj">'X4aSs`i!e13jhuA3~>
+b5VMCM#QH7"NUQCdJj.F"*O]prosF`IfSU1rrDZj">'X4aSs`i!e13jhuA3~>
+b5VMCM#QH7"NUQCdJj.F"*O]prosF`IfSU1rrDZj">'X4aSs`i!e13jhuA3~>
+bPqXa!.X#."#^/+rqufr!9jF`IfSX2""jV(rq$-m/cYn!rmq)N`rLVHs*t~>
+bPqXa!.X#."#^/+rqufr!9jF`IfSX2""jV(rq$-m/cYn!rmq)N`rLVHs*t~>
+bPqXa!.X#."#^/+rqufr!9jF`IfSX2""jV(rq$-m/cYn!rmq)N`rLVHs*t~>
+bPqWn!6=."!\FF*qu6ctL]GK[rrITLkPkV(!&j?H"OI,KdJh_s!W\&Ui;\<~>
+bPqWn!6=."!\FF*qu6ctL]GK[rrITLkPkV(!&j?H"OI,KdJh_s!W\&Ui;\<~>
+bPqWn!6=."!\FF*qu6ctL]GK[rrITLkPkV(!&j?H"OI,KdJh_s!W\&Ui;\<~>
+bPqT%!9=(\/cdR"rr^:AM#Q]>!Ik+4rrP+Za70*4rm:]GdJhbtrrCsVJ,~>
+bPqT%!9=(\/cdR"rr^:AM#Q]>!Ik+4rrP+Za70*4rm:]GdJhbtrrCsVJ,~>
+bPqT%!9=(\/cdR"rr^:AM#Q]>!Ik+4rrP+Za70*4rm:]GdJhbtrrCsVJ,~>
+bPqSC2s(&Arm1X'p](6nl2Ld6!9sLcrm1X(mf*Iid/X0orn7;QreLR3s*t~>
+bPqSC2s(&Arm1X'p](6nl2Ld6!9sLcrm1X(mf*Iid/X0orn7;QreLR3s*t~>
+bPqSC2s(&Arm1X'p](6nl2Ld6!9sLcrm1X(mf*Iid/X0orn7;QreLR3s*t~>
+bPqSCJ*-b6rm:]GaS>c;rdOrllMgm7!9jI_!!(+-rri>K!!(BurrRZMa5HuJ~>
+bPqSCJ*-b6rm:]GaS>c;rdOrllMgm7!9jI_!!(+-rri>K!!(BurrRZMa5HuJ~>
+bPqSCJ*-b6rm:]GaS>c;rdOrllMgm7!9jI_!!(+-rri>K!!(BurrRZMa5HuJ~>
+bl7`f!I!W*"NUQCdJik>!<>(DrrITLlMh"dIfY&um/I4fd/X/!g&D,o!.Wr,J,~>
+bl7`f!I!W*"NUQCdJik>!<>(DrrITLlMh"dIfY&um/I4fd/X/!g&D,o!.Wr,J,~>
+bl7`f!I!W*"NUQCdJik>!<>(DrrITLlMh"dIfY&um/I4fd/X/!g&D,o!.Wr,J,~>
+bl7]n!9O4_2?;,'p&>%O!:'RbIfSa5rrD<`"THJ#!A3")!<@W-s*t~>
+bl7]n!9O4_2?;,'p&>%O!:'RbIfSa5rrD<`"THJ#!A3")!<@W-s*t~>
+bl7]n!9O4_2?;,'p&>%O!:'RbIfSa5rrD<`"THJ#!A3")!<@W-s*t~>
+bl7]&!9X:_/HIKqrr[EFJ,\g7!Ik+7rrXkSJ,\X2!\FF)gA_0R2rO^d~>
+bl7]&!9X:_/HIKqrr[EFJ,\g7!Ik+7rrXkSJ,\X2!\FF)gA_0R2rO^d~>
+bl7]&!9X:_/HIKqrr[EFJ,\g7!Ik+7rrXkSJ,\X2!\FF)gA_0R2rO^d~>
+bl7\D2s:2B/cdQos8N)brrITLli.%,!&ip<!\FF)g]%:5!9!m-~>
+bl7\D2s:2B/cdQos8N)brrITLli.%,!&ip<!\FF)g]%:5!9!m-~>
+bl7\D2s:2B/cdQos8N)brrITLli.%,!&ip<!\FF)g]%:5!9!m-~>
+c2Rjc!.X85"9-XI2Y$eLreLQpm/I*9!:0Xd2ZUnYrrObQ/_p@,IfSF,J,~>
+c2Rjc!.X85"9-XI2Y$eLreLQpm/I*9!:0Xd2ZUnYrrObQ/_p@,IfSF,J,~>
+c2Rjc!.X85"9-XI2Y$eLreLQpm/I*9!:0Xd2ZUnYrrObQ/_p@,IfSF,J,~>
+c2Rip!6=C)"THdK!6F[0"31CtrpB^dIfSm9"9-XI2rXc>/HIcNrnm_WFocdFs*t~>
+c2Rip!6=C)"THdK!6F[0"31CtrpB^dIfSm9"9-XI2rXc>/HIcNrnm_WFocdFs*t~>
+c2Rip!6=C)"THdK!6F[0"31CtrpB^dIfSm9"9-XI2rXc>/HIcNrnm_WFocdFs*t~>
+cMmtFL]H]>"NUQCdJiV7rrDEc!Ik+9s8N'!aPd($/cYn!rnm_V!.Wu-J,~>
+cMmtFL]H]>"NUQCdJiV7rrDEc!Ik+9s8N'!aPd($/cYn!rnm_V!.Wu-J,~>
+cMmtFL]H]>"NUQCdJiV7rrDEc!Ik+9s8N'!aPd($/cYn!rnm_V!.Wu-J,~>
+c2[eDl2LiD!7:`6rr`7M!I!l1!Ik+;rri=N!It++rrg[K!7Cf(rrE*YiW"E~>
+c2[eDl2LiD!7:`6rr`7M!I!l1!Ik+;rri=N!It++rrg[K!7Cf(rrE*YiW"E~>
+c2[eDl2LiD!7:`6rr`7M!I!l1!Ik+;rri=N!It++rrg[K!7Cf(rrE*YiW"E~>
+c2RhFM#Q`?!\FF*li-tc2spVGIfSm9rrCmT"ocmL!7Cf)rrG%YiW"E~>
+c2RhFM#Q`?!\FF*li-tc2spVGIfSm9rrCmT"ocmL!7Cf)rrG%YiW"E~>
+c2RhFM#Q`?!\FF*li-tc2spVGIfSm9rrCmT"ocmL!7Cf)rrG%YiW"E~>
+cMmsd!.X>7!\OL*lMglD!:BdeIfSp:""jV(rn[SXrm:]GdJi/*!Ik+.s*t~>
+cMmsd!.X>7!\OL*lMglD!:BdeIfSp:""jV(rn[SXrm:]GdJi/*!Ik+.s*t~>
+cMmsd!.X>7!\OL*lMglD!:BdeIfSp:""jV(rn[SXrm:]GdJi/*!Ik+.s*t~>
+cMmrq!6=L,"9-XI2X15DFod*ln,EE<!:Tph`rJ$Orri>K!!(C*rrRZMa5[,L~>
+cMmrq!6=L,"9-XI2X15DFod*ln,EE<!:Tph`rJ$Orri>K!!(C*rrRZMa5[,L~>
+cMmrq!6=L,"9-XI2X15DFod*ln,EE<!:Tph`rJ$Orri>K!!(C*rrRZMa5[,L~>
+cMmo(!:Bdhrm:]GaQW[(!:KjfIfSs;!]L,"g&D3Sd/X/!j8T2$!.X#.J,~>
+cMmo(!:Bdhrm:]GaQW[(!:KjfIfSs;!]L,"g&D3Sd/X/!j8T2$!.X#.J,~>
+cMmo(!:Bdhrm:]GaQW[(!:KjfIfSs;!]L,"g&D3Sd/X/!j8T2$!.X#.J,~>
+cMmnF2spVJa8c4frosFbreLQpn,EE<!:g'krm1X(fDc!Qa>O&Nj8T/\M#QH7J,~>
+cMmnF2spVJa8c4frosFbreLQpn,EE<!:g'krm1X(fDc!Qa>O&Nj8T/\M#QH7J,~>
+cMmnF2spVJa8c4frosFbreLQpn,EE<!:g'krm1X(fDc!Qa>O&Nj8T/\M#QH7J,~>
+cMmnFJ*m7<2?;,'kPkY)!/UXDrrITLnGiLg!6E[i!\FF)jT#5[ir=N~>
+cMmnFJ*m7<2?;,'kPkY)!/UXDrrITLnGiLg!6E[i!\FF)jT#5[ir=N~>
+cMmnFJ*m7<2?;,'kPkY)!/UXDrrITLnGiLg!6E[i!\FF)jT#5[ir=N~>
+ci4&i!I!o2!\FF*jT#5[o`"s,G5hLGIfTNKrlB<Zrs$5^s*k'!rmUlK/HIHfrrp/\s8IfSrr3'!
+aEQkJJ,~>
+ci4&i!I!o2!\FF*jT#5[o`"s,G5hLGIfTNKrlB<Zrs$5^s*k'!rmUlK/HIHfrrp/\s8IfSrr3'!
+aEQkJJ,~>
+ci4&i!I!o2!\FF*jT#5[o`"s,G5hLGIfTNKrlB<Zrs$5^s*k'!rmUlK/HIHfrrp/\s8IfSrr3'!
+aEQkJJ,~>
+ci4#q!:Kjg/cdQbrr`7M!I"/9$[)P&s8RQKs8LCG!;ZWtIfTKK!7:`I/HIHgrsNuN/cU;#a8c.d
+!!)6_J,~>
+ci4#q!:Kjg/cdQbrr`7M!I"/9$[)P&s8RQKs8LCG!;ZWtIfTKK!7:`I/HIHgrsNuN/cU;#a8c.d
+!!)6_J,~>
+ci4#q!:Kjg/cdQbrr`7M!I"/9$[)P&s8RQKs8LCG!;ZWtIfTKK!7:`I/HIHgrsNuN/cU;#a8c.d
+!!)6_J,~>
+ci4#)!:^!jrm1X'iVroY2t[+X/HII'IfTMr!!(FGqYp_K!'UF5rm:ZJ/HIcNrp9Xm/HIHU!.Y!q
+!!(FGl2Q8~>
+ci4#)!:^!jrm1X'iVroY2t[+X/HII'IfTMr!!(FGqYp_K!'UF5rm:ZJ/HIcNrp9Xm/HIHU!.Y!q
+!!(FGl2Q8~>
+ci4#)!:^!jrm1X'iVroY2t[+X/HII'IfTMr!!(FGqYp_K!'UF5rm:ZJ/HIcNrp9Xm/HIHU!.Y!q
+!!(FGl2Q8~>
+h>[KSqYpQpr;Qct2t?nNrm:]GaPm."2ZWIL#qZ00O9"5>!7CfArr[`N!&i+%">0ZSdJiM4#qZ0A
+!.N;q!7Cf0s*t~>
+h>[KSqYpQpr;Qct2t?nNrm:]GaPm."2ZWIL#qZ00O9"5>!7CfArr[`N!&i+%">0ZSdJiM4#qZ0A
+!.N;q!7Cf0s*t~>
+h>[KSqYpQpr;Qct2t?nNrm:]GaPm."2ZWIL#qZ00O9"5>!7CfArr[`N!&i+%">0ZSdJiM4#qZ0A
+!.N;q!7Cf0s*t~>
+iVs)\s2])&*rKp^*dDSDs8L%=J+<OAa8c4fro*kZFod*lo`"qD!W;uuiV3?SIfKJhbl7gm!!(FG
+nc&UgrVm*d!!#Oi!7Cf/s*t~>
+iVs)\s2])&*rKp^*dDSDs8L%=J+<OAa8c4fro*kZFod*lo`"qD!W;uuiV3?SIfKJhbl7gm!!(FG
+nc&UgrVm*d!!#Oi!7Cf/s*t~>
+iVs)\s2])&*rKp^*dDSDs8L%=J+<OAa8c4fro*kZFod*lo`"qD!W;uuiV3?SIfKJhbl7gm!!(FG
+nc&UgrVm*d!!#Oi!7Cf/s*t~>
+ir9,%G91Yqrrm9]G<c/Knc&\L!7:`&s8N)is8;p&M/I6MGTLd@rVm(O!!%e(Is96="ocmL!7Cf>
+rrrE%aDQ5Drbhg]2Z<[XOoPFDs*t~>
+ir9,%G91Yqrrm9]G<c/Knc&\L!7:`&s8N)is8;p&M/I6MGTLd@rVm(O!!%e(Is96="ocmL!7Cf>
+rrrE%aDQ5Drbhg]2Z<[XOoPFDs*t~>
+ir9,%G91Yqrrm9]G<c/Knc&\L!7:`&s8N)is8;p&M/I6MGTLd@rVm(O!!%e(Is96="ocmL!7Cf>
+rrrE%aDQ5Drbhg]2Z<[XOoPFDs*t~>
+jSo;&*I%#Q!\OK"o)AbC!A<7/"9+)Va8#Z@rr6jWGL8#CdJj.F#lal(aEJ\Cs*"8>cMn(Id/X0o
+rqQKqaEJ\Cq>UXO!8262GKB"JJ,~>
+jSo;&*I%#Q!\OK"o)AbC!A<7/"9+)Va8#Z@rr6jWGL8#CdJj.F#lal(aEJ\Cs*"8>cMn(Id/X0o
+rqQKqaEJ\Cq>UXO!8262GKB"JJ,~>
+jSo;&*I%#Q!\OK"o)AbC!A<7/"9+)Va8#Z@rr6jWGL8#CdJj.F#lal(aEJ\Cs*"8>cMn(Id/X0o
+rqQKqaEJ\Cq>UXO!8262GKB"JJ,~>
+k5PS**I%P_mf*?4*Q[pR!\OL*h#@Js!/UXOrs&K&G9+d)rr2otrqZQsrr:%[J,B6Grm(NHrm:]G
+d/*bDa;oKsrrE&trrRBbaQieU~>
+k5PS**I%P_mf*?4*Q[pR!\OL*h#@Js!/UXOrs&K&G9+d)rr2otrqZQsrr:%[J,B6Grm(NHrm:]G
+d/*bDa;oKsrrE&trrRBbaQieU~>
+k5PS**I%P_mf*?4*Q[pR!\OL*h#@Js!/UXOrs&K&G9+d)rr2otrqZQsrr:%[J,B6Grm(NHrm:]G
+d/*bDa;oKsrrE&trrRBbaQieU~>
+kPkW)GQ7[/rr`9#G9-JY"9-XI2VS32!;uj"rr70_aR0!1a;oL)rlY6Drm:]G0)beQa;oL)rp]pj
+rr70_aR&qW~>
+kPkW)GQ7[/rr`9#G9-JY"9-XI2VS32!;uj"rr70_aR0!1a;oL)rlY6Drm:]G0)beQa;oL)rp]pj
+rr70_aR&qW~>
+kPkW)GQ7[/rr`9#G9-JY"9-XI2VS32!;uj"rr70_aR0!1a;oL)rlY6Drm:]G0)beQa;oL)rp]pj
+rr70_aR&qW~>
+lMh"druBJdkl1ebdN&;dr;Qp!d/X0fg]%BTIfX`lrr`8K*6@CE"3;J1rlY6Jrl?tu/cYhkGQ7[/
+rr`9#G9-)NJ,~>
+lMh"druBJdkl1ebdN&;dr;Qp!d/X0fg]%BTIfX`lrr`8K*6@CE"3;J1rlY6Jrl?tu/cYhkGQ7[/
+rr`9#G9-)NJ,~>
+lMh"druBJdkl1ebdN&;dr;Qp!d/X0fg]%BTIfX`lrr`8K*6@CE"3;J1rlY6Jrl?tu/cYhkGQ7[/
+rr`9#G9-)NJ,~>
+li.+edN$C.k5PS`aW/b.rVm#A!!(FGg&D'Q2u`gXd2_9J!?BM-rrjtT2C6fNkl1ebdN&;dnGe"~>
+li.+edN$C.k5PS`aW/b.rVm#A!!(FGg&D'Q2u`gXd2_9J!?BM-rrjtT2C6fNkl1ebdN&;dnGe"~>
+li.+edN$C.k5PS`aW/b.rVm#A!!(FGg&D'Q2u`gXd2_9J!?BM-rrjtT2C6fNkl1ebdN&;dnGe"~>
+m/I.ddN%3F!Z]Yfrr3'Y!7:_trrk=]s8O*`j8T.(*QS0^5QK42k5PS`aW/b.nc++~>
+m/I.ddN%3F!Z]Yfrr3'Y!7:_trrk=]s8O*`j8T.(*QS0^5QK42k5PS`aW/b.nc++~>
+m/I.ddN%3F!Z]Yfrr3'Y!7:_trrk=]s8O*`j8T.(*QS0^5QK42k5PS`aW/b.nc++~>
+m/I+.*8^]"*6J6\/HIKTrrmQHLE+bAj8T2[dN$F0"THghs8M$X!Z]Yfo)F4~>
+m/I+.*8^]"*6J6\/HIKTrrmQHLE+bAj8T2[dN$F0"THghs8M$X!Z]Yfo)F4~>
+m/I+.*8^]"*6J6\/HIKTrrmQHLE+bAj8T2[dN$F0"THghs8M$X!Z]Yfo)F4~>
+m/I&*h#@Kss"4=(eGoOK!R^o*rrW2J*R"H`aW01;!?B5Ps*t~>
+m/I&*h#@Kss"4=(eGoOK!R^o*rrW2J*R"H`aW01;!?B5Ps*t~>
+m/I&*h#@Kss"4=(eGoOK!R^o*rrW2J*R"H`aW01;!?B5Ps*t~>
+mJd5.df/,'"THe,!&i@,!r\8^hZ!]WGL?E7rr=%orr=&0s*t~>
+mJd5.df/,'"THe,!&i@,!r\8^hZ!]WGL?E7rr=%orr=&0s*t~>
+mJd5.df/,'"THe,!&i@,!r\8^hZ!]WGL?E7rr=%orr=&0s*t~>
+n,ELhd<GTFrr^:A!6<Uh"3DP_rn[ST*6HM+!Zf_ghZ!ZVdN.rZJ,~>
+n,ELhd<GTFrr^:A!6<Uh"3DP_rn[ST*6HM+!Zf_ghZ!ZVdN.rZJ,~>
+n,ELhd<GTFrr^:A!6<Uh"3DP_rn[ST*6HM+!Zf_ghZ!ZVdN.rZJ,~>
+mf*8,q>UZ>PCf(Os8M9_!d=W'e,KCfp&>$kk5PE$d/O4Id<GTgrrE&Wrr`7EdJih=J,~>
+mf*8,q>UZ>PCf(Os8M9_!d=W'e,KCfp&>$kk5PE$d/O4Id<GTgrrE&Wrr`7EdJih=J,~>
+mf*8,q>UZ>PCf(Os8M9_!d=W'e,KCfp&>$kk5PE$d/O4Id<GTgrrE&Wrr`7EdJih=J,~>
+nG`RhGKBa_"9/=K!rN$"2"gk3rrU5brn%/Prccchr;Qt]2Zj$a7EXfn"9-\lrmC`G*<#mErr:/J
+)#sXYHiO*.rr=&2s*t~>
+nG`RhGKBa_"9/=K!rN$"2"gk3rrU5brn%/Prccchr;Qt]2Zj$a7EXfn"9-\lrmC`G*<#mErr:/J
+)#sXYHiO*.rr=&2s*t~>
+nG`RhGKBa_"9/=K!rN$"2"gk3rrU5brn%/Prccchr;Qt]2Zj$a7EXfn"9-\lrmC`G*<#mErr:/J
+)#sXYHiO*.rr=&2s*t~>
+n,EA.r;QuS%KHK2GROKN!$CA'!$0Vi!$2(=!ri4eq#CD]k5PE%df0CJGKBa_!U`#F!!3o1roj@`
+aERXWs*t~>
+n,EA.r;QuS%KHK2GROKN!$CA'!$0Vi!$2(=!ri4eq#CD]k5PE%df0CJGKBa_!U`#F!!3o1roj@`
+aERXWs*t~>
+n,EA.r;QuS%KHK2GROKN!$CA'!$0Vi!$2(=!ri4eq#CD]k5PE%df0CJGKBa_!U`#F!!3o1roj@`
+aERXWs*t~>
+nG`N,aSl,=_YsN;dJs6jr;Zi+kPkS(DV4surccH`s8N$j!!#:Ks(2-/!:8nK!m#Tbe,KCgrVll?
+rW!%us5!nX!!$?frr=)4s*t~>
+nG`N,aSl,=_YsN;dJs6jr;Zi+kPkS(DV4surccH`s8N$j!!#:Ks(2-/!:8nK!m#Tbe,KCgrVll?
+rW!%us5!nX!!$?frr=)4s*t~>
+nG`N,aSl,=_YsN;dJs6jr;Zi+kPkS(DV4surccH`s8N$j!!#:Ks(2-/!:8nK!m#Tbe,KCgrVll?
+rW!%us5!nX!!$?frr=)4s*t~>
+nG`J0rr3#ud/F"FX8W(s!!%c9rr=+lrsTtKs8N$X!!#+\rr;]j!!&>Irr=+hrrI#Yrr2u<rVurC
+rr2t2rVup&k5PJ'DYF*\~>
+nG`J0rr3#ud/F"FX8W(s!!%c9rr=+lrsTtKs8N$X!!#+\rr;]j!!&>Irr=+hrrI#Yrr2u<rVurC
+rr2t2rVup&k5PJ'DYF*\~>
+nG`J0rr3#ud/F"FX8W(s!!%c9rr=+lrsTtKs8N$X!!#+\rr;]j!!&>Irr=+hrrI#Yrr2u<rVurC
+rr2t2rVup&k5PJ'DYF*\~>
+nc&p:GQ.XAoE5-o0)YbJ!!&5GrrW1DaP$RoaDV"W!*B."!Vu`os8;otKBE17DTL?-"<RUCro3nW
+!-A,=!.4YEjo5<%pA]X~>
+nc&p:GQ.XAoE5-o0)YbJ!!&5GrrW1DaP$RoaDV"W!*B."!Vu`os8;otKBE17DTL?-"<RUCro3nW
+!-A,=!.4YEjo5<%pA]X~>
+nc&p:GQ.XAoE5-o0)YbJ!!&5GrrW1DaP$RoaDV"W!*B."!Vu`os8;otKBE17DTL?-"<RUCro3nW
+!-A,=!.4YEjo5<%pA]X~>
+nc&T,rVlj\rW!,0rr<#tcM[_CjlQLBDV>$i*WH'=U](5nGl@XBmem+cZfV2e*S(/naERX_rtYM5
+!;ufq!+5^*!$gY+!rdDbp]#a~>
+nc&T,rVlj\rW!,0rr<#tcM[_CjlQLBDV>$i*WH'=U](5nGl@XBmem+cZfV2e*S(/naERX_rtYM5
+!;ufq!+5^*!$gY+!rdDbp]#a~>
+nc&T,rVlj\rW!,0rr<#tcM[_CjlQLBDV>$i*WH'=U](5nGl@XBmem+cZfV2e*S(/naERX_rtYM5
+!;ufq!+5^*!$gY+!rdDbp]#a~>
+nc&_5s8W).r;ccq!+5^*!+4ge!$9hn"*jhEq>C9njo58\rh'/i!"J&i!WI>orr?s9rr@9B!!$!r
+rr<T/!!&GJrr?s2s*t~>
+nc&_5s8W).r;ccq!+5^*!+4ge!$9hn"*jhEq>C9njo58\rh'/i!"J&i!WI>orr?s9rr@9B!!$!r
+rr<T/!!&GJrr?s2s*t~>
+nc&_5s8W).r;ccq!+5^*!+4ge!$9hn"*jhEq>C9njo58\rh'/i!"J&i!WI>orr?s9rr@9B!!$!r
+rr<T/!!&GJrr?s2s*t~>
+nc&`:rr<!GrVupPrVll<rW!!Ws8M0\!WI>trrgD\s8Qm6!!!c5rrW3"'`J(5c2Qi)!H-!0rrX>B
+s7Q<j!N,kqrrA\j!!#+@rr=,7s*t~>
+nc&`:rr<!GrVupPrVll<rW!!Ws8M0\!WI>trrgD\s8Qm6!!!c5rrW3"'`J(5c2Qi)!H-!0rrX>B
+s7Q<j!N,kqrrA\j!!#+@rr=,7s*t~>
+nc&`:rr<!GrVupPrVll<rW!!Ws8M0\!WI>trrgD\s8Qm6!!!c5rrW3"'`J(5c2Qi)!H-!0rrX>B
+s7Q<j!N,kqrrA\j!!#+@rr=,7s*t~>
+nc&]/s8U^L!!HX.rr9D*!!6p8roF(ZDZ9Y;rlB<Arr?s9s8;p$8H8_hs$Zhd!6!ms!,hc8!rg8b
+h>[S%rr7BE!!([NrrC=C!!5UhroO.\rcn2;J,~>
+nc&]/s8U^L!!HX.rr9D*!!6p8roF(ZDZ9Y;rlB<Arr?s9s8;p$8H8_hs$Zhd!6!ms!,hc8!rg8b
+h>[S%rr7BE!!([NrrC=C!!5UhroO.\rcn2;J,~>
+nc&]/s8U^L!!HX.rr9D*!!6p8roF(ZDZ9Y;rlB<Arr?s9s8;p$8H8_hs$Zhd!6!ms!,hc8!rg8b
+h>[S%rr7BE!!([NrrC=C!!5UhroO.\rcn2;J,~>
+o)Ai1aT)9fr;[.Es4'U>!%lY!ro="_aDV%Wd/X1*rri=Gs8Jno!!mB?s4\h"!'K`/rs*fJs8W)G
+!!(jT")e/=(&\+7qZ$SKrW!"gs8M'Y!,hQ2J,~>
+o)Ai1aT)9fr;[.Es4'U>!%lY!ro="_aDV%Wd/X1*rri=Gs8Jno!!mB?s4\h"!'K`/rs*fJs8W)G
+!!(jT")e/=(&\+7qZ$SKrW!"gs8M'Y!,hQ2J,~>
+o)Ai1aT)9fr;[.Es4'U>!%lY!ro="_aDV%Wd/X1*rri=Gs8Jno!!mB?s4\h"!'K`/rs*fJs8W)G
+!!(jT")e/=(&\+7qZ$SKrW!"gs8M'Y!,hQ2J,~>
+o)A].rr2sZr;['[+TML5`rH%rrs!E@d/X0oro*kZ*rl7Cr;[+JZU4]m1W'1kiVs0)s8W)G!!(FG
+hu<draT(N&!!_e?#64aKrS[\VaDUeQJ,~>
+o)A].rr2sZr;['[+TML5`rH%rrs!E@d/X0oro*kZ*rl7Cr;[+JZU4]m1W'1kiVs0)s8W)G!!(FG
+hu<draT(N&!!_e?#64aKrS[\VaDUeQJ,~>
+o)A].rr2sZr;['[+TML5`rH%rrs!E@d/X0oro*kZ*rl7Cr;[+JZU4]m1W'1kiVs0)s8W)G!!(FG
+hu<draT(N&!!_e?#64aKrS[\VaDUeQJ,~>
+o)A].rr2s.qu?jWPP>+Vqu6Zqjo5L%d/X0oro!eYDu]h]qZ$a&C"r[ehu<q"s8LCG!7Cf&rr[3>
+s0;D#!B$M)rr@!4s*t~>
+o)A].rr2s.qu?jWPP>+Vqu6Zqjo5L%d/X0oro!eYDu]h]qZ$a&C"r[ehu<q"s8LCG!7Cf&rr[3>
+s0;D#!B$M)rr@!4s*t~>
+o)A].rr2s.qu?jWPP>+Vqu6Zqjo5L%d/X0oro!eYDu]h]qZ$a&C"r[ehu<q"s8LCG!7Cf&rr[3>
+s0;D#!B$M)rr@!4s*t~>
+o)A].rr;lr!%@UA!rhhUk5PQD!!(FGhu<ars8Vus"<P\bs8Mio!9!#>#&jOh!!(FGh>[Rqs8S/X
+!!@]Bs8Mlp!WM3Brr@!4s*t~>
+o)A].rr;lr!%@UA!rhhUk5PQD!!(FGhu<ars8Vus"<P\bs8Mio!9!#>#&jOh!!(FGh>[Rqs8S/X
+!!@]Bs8Mlp!WM3Brr@!4s*t~>
+o)A].rr;lr!%@UA!rhhUk5PQD!!(FGhu<ars8Vus"<P\bs8Mio!9!#>#&jOh!!(FGh>[Rqs8S/X
+!!@]Bs8Mlp!WM3Brr@!4s*t~>
+o)A].rr;iq!U]m_rr`8m&qKo[!<2rs!<2Qh"NLKB8:KHG",AgZs8)firrIt"qYpZaP)88irrm>n
+!!#Q=h1,HKs8N(Mqu?_Vq#:Epo`F7T!,qZ4J,~>
+o)A].rr;iq!U]m_rr`8m&qKo[!<2rs!<2Qh"NLKB8:KHG",AgZs8)firrIt"qYpZaP)88irrm>n
+!!#Q=h1,HKs8N(Mqu?_Vq#:Epo`F7T!,qZ4J,~>
+o)A].rr;iq!U]m_rr`8m&qKo[!<2rs!<2Qh"NLKB8:KHG",AgZs8)firrIt"qYpZaP)88irrm>n
+!!#Q=h1,HKs8N(Mqu?_Vq#:Epo`F7T!,qZ4J,~>
+o)A].rr2s&qu?_3qYp]tlOO#Br;QuA-NF-Dq>U!c!-Zup!<;or!OMe&rri?$KE-N!rrnHAG7+Dd
+o)A`/L=cJ.JH,Y*qu?^>q>UQrnIbj"rs&JHIXciramoB2Dts?_~>
+o)A].rr2s&qu?_3qYp]tlOO#Br;QuA-NF-Dq>U!c!-Zup!<;or!OMe&rri?$KE-N!rrnHAG7+Dd
+o)A`/L=cJ.JH,Y*qu?^>q>UQrnIbj"rs&JHIXciramoB2Dts?_~>
+o)A].rr2s&qu?_3qYp]tlOO#Br;QuA-NF-Dq>U!c!-Zup!<;or!OMe&rri?$KE-N!rrnHAG7+Dd
+o)A`/L=cJ.JH,Y*qu?^>q>UQrnIbj"rs&JHIXciramoB2Dts?_~>
+o)A]-rr2sZqZ%#=s8N&urr:%A!#+burs#tIjSs0!5OndR!!#4=rr[HEruCq:!Z:t:rVm'#s(VN6
+U&=opXZZX`dJt<Yrrd9?/H@uhrr[0=s/c(t!2B>i"5jLe%/^&)7K!2doC;h\Dts?_~>
+o)A]-rr2sZqZ%#=s8N&urr:%A!#+burs#tIjSs0!5OndR!!#4=rr[HEruCq:!Z:t:rVm'#s(VN6
+U&=opXZZX`dJt<Yrrd9?/H@uhrr[0=s/c(t!2B>i"5jLe%/^&)7K!2doC;h\Dts?_~>
+o)A]-rr2sZqZ%#=s8N&urr:%A!#+burs#tIjSs0!5OndR!!#4=rr[HEruCq:!Z:t:rVm'#s(VN6
+U&=opXZZX`dJt<Yrrd9?/H@uhrr[0=s/c(t!2B>i"5jLe%/^&)7K!2doC;h\Dts?_~>
+o)Aj6DZBa#q>^kBh>dMr;ucnAq#:6l!>/Z;s8N)irrd5m/HIH[rr[NFs'bd)!B'`PrrhI@!!&/Y
+rrF$Nrr;uuoD]$oGlRdq!A3+,")e/=o(i=dX8Mu$Q2gn$p&=mh"[e<$Np?W6rr?s3s*t~>
+o)Aj6DZBa#q>^kBh>dMr;ucnAq#:6l!>/Z;s8N)irrd5m/HIH[rr[NFs'bd)!B'`PrrhI@!!&/Y
+rrF$Nrr;uuoD]$oGlRdq!A3+,")e/=o(i=dX8Mu$Q2gn$p&=mh"[e<$Np?W6rr?s3s*t~>
+o)Aj6DZBa#q>^kBh>dMr;ucnAq#:6l!>/Z;s8N)irrd5m/HIH[rr[NFs'bd)!B'`PrrhI@!!&/Y
+rrF$Nrr;uuoD]$oGlRdq!A3+,")e/=o(i=dX8Mu$Q2gn$p&=mh"[e<$Np?W6rr?s3s*t~>
+nc&T-rr2s'oDeq[s8Mrr"p.m+s7$(,o)Al3s8OYO/`6R1*rl5hq#CLlG]GbB!!'5!s8N'%Y5dS`
+'_;8(*rc0@/HIHZrrgD\s8P@\!!s]\HX-mW!&4BNr;Qi:T)S0X!H-!Rs*t~>
+nc&T-rr2s'oDeq[s8Mrr"p.m+s7$(,o)Al3s8OYO/`6R1*rl5hq#CLlG]GbB!!'5!s8N'%Y5dS`
+'_;8(*rc0@/HIHZrrgD\s8P@\!!s]\HX-mW!&4BNr;Qi:T)S0X!H-!Rs*t~>
+nc&T-rr2s'oDeq[s8Mrr"p.m+s7$(,o)Al3s8OYO/`6R1*rl5hq#CLlG]GbB!!'5!s8N'%Y5dS`
+'_;8(*rc0@/HIHZrrgD\s8P@\!!s]\HX-mW!&4BNr;Qi:T)S0X!H-!Rs*t~>
+nc&_5s8W)=o`,&Ns8Mrr!<2rs"+UBorq$-i*rc0@/HIK^rr@!:rr?*m!!*JXq>UZ$YlF`T!0$LK
+!,qi9!\FF*h>[Rqs8M'N!!6a3rql]rDWL3b!,qW3J,~>
+nc&_5s8W)=o`,&Ns8Mrr!<2rs"+UBorq$-i*rc0@/HIK^rr@!:rr?*m!!*JXq>UZ$YlF`T!0$LK
+!,qi9!\FF*h>[Rqs8M'N!!6a3rql]rDWL3b!,qW3J,~>
+nc&_5s8W)=o`,&Ns8Mrr!<2rs"+UBorq$-i*rc0@/HIK^rr@!:rr?*m!!*JXq>UZ$YlF`T!0$LK
+!,qi9!\FF*h>[Rqs8M'N!!6a3rql]rDWL3b!,qW3J,~>
+o)AaiGl@XC_?'H4!B/p1rr[pW?hEmg!I4VCrrF_Pi;WsuaT)8>1%tYL;#C7drr`8a!&jEJ!Q]0V
+rrF_Ph>[Hrrr2u1pAb:"[f?@'rrjgFK<P=Snc&S1p]#a~>
+o)AaiGl@XC_?'H4!B/p1rr[pW?hEmg!I4VCrrF_Pi;WsuaT)8>1%tYL;#C7drr`8a!&jEJ!Q]0V
+rrF_Ph>[Hrrr2u1pAb:"[f?@'rrjgFK<P=Snc&S1p]#a~>
+o)AaiGl@XC_?'H4!B/p1rr[pW?hEmg!I4VCrrF_Pi;WsuaT)8>1%tYL;#C7drr`8a!&jEJ!Q]0V
+rrF_Ph>[Hrrr2u1pAb:"[f?@'rrjgFK<P=Snc&S1p]#a~>
+nc&W-aSl,Gr.?O#!!+Qddf9=?rr[j^!1!-T!Q]0UrrE&Vrrm<?s8N%Jq>^U_bQ%S9rrrDk$UOgl
+oD\f.q>UHohu<`VGl@XCgFrF(!t9_[rqQNnH3@(F)"[atrrIBDq#>j~>
+nc&W-aSl,Gr.?O#!!+Qddf9=?rr[j^!1!-T!Q]0UrrE&Vrrm<?s8N%Jq>^U_bQ%S9rrrDk$UOgl
+oD\f.q>UHohu<`VGl@XCgFrF(!t9_[rqQNnH3@(F)"[atrrIBDq#>j~>
+nc&W-aSl,Gr.?O#!!+Qddf9=?rr[j^!1!-T!Q]0UrrE&Vrrm<?s8N%Jq>^U_bQ%S9rrrDk$UOgl
+oD\f.q>UHohu<`VGl@XCgFrF(!t9_[rqQNnH3@(F)"[atrrIBDq#>j~>
+nG`J/p&>$ko`#'ns#U5-oD\e2f`(pmqu6o5NId2&qZ$QgrrrDb!-eJBo)A\2ec,YfaSu2Err;#O
+K8?2Pnc&Zn!(ZV[!Q]0Qs*t~>
+nG`J/p&>$ko`#'ns#U5-oD\e2f`(pmqu6o5NId2&qZ$QgrrrDb!-eJBo)A\2ec,YfaSu2Err;#O
+K8?2Pnc&Zn!(ZV[!Q]0Qs*t~>
+nG`J/p&>$ko`#'ns#U5-oD\e2f`(pmqu6o5NId2&qZ$QgrrrDb!-eJBo)A\2ec,YfaSu2Err;#O
+K8?2Pnc&Zn!(ZV[!Q]0Qs*t~>
+nc&XhGO#2/_o;WT!dOd!oD\i8rn@ARrccHKrs/Pf!k84/s8MZj!m#Tbec,Uijo>>\o)A\1pA]X~>
+nc&XhGO#2/_o;WT!dOd!oD\i8rn@ARrccHKrs/Pf!k84/s8MZj!m#Tbec,Uijo>>\o)A\1pA]X~>
+nc&XhGO#2/_o;WT!dOd!oD\i8rn@ARrccHKrs/Pf!k84/s8MZj!m#Tbec,Uijo>>\o)A\1pA]X~>
+nG`R2GQ."0!g`o%rr3%0!1if_!rdDbfDbkqrp9Xerqm>irr2slo`"skGLZWnrcd`/!rhZ*rr3&k
+!!;`k!I+P;s*t~>
+nG`R2GQ."0!g`o%rr3%0!1if_!rdDbfDbkqrp9Xerqm>irr2slo`"skGLZWnrcd`/!rhZ*rr3&k
+!!;`k!I+P;s*t~>
+nG`R2GQ."0!g`o%rr3%0!1if_!rdDbfDbkqrp9Xerqm>irr2slo`"skGLZWnrcd`/!rhZ*rr3&k
+!!;`k!I+P;s*t~>
+n,EA.m/I?U!<<)urrrZ+o`"n3f)G^jlMgod(BaX:!-.W1!$0Pg!m#TbmJdCkJH#TKM#^]NrrW1D
+aS,Xa~>
+n,EA.m/I?U!<<)urrrZ+o`"n3f)G^jlMgod(BaX:!-.W1!$0Pg!m#TbmJdCkJH#TKM#^]NrrW1D
+aS,Xa~>
+n,EA.m/I?U!<<)urrrZ+o`"n3f)G^jlMgod(BaX:!-.W1!$0Pg!m#TbmJdCkJH#TKM#^]NrrW1D
+aS,Xa~>
+n,EI1GQ.%1#l5!Ds6qufj8ScP!rdDbf)GfmGQ-t/qu?dLr;QEi!rdDbdf0:fm/I>B,3Jp$!#55-
+o`"n3p&BO~>
+n,EI1GQ.%1#l5!Ds6qufj8ScP!rdDbf)GfmGQ-t/qu?dLr;QEi!rdDbdf0:fm/I>B,3Jp$!#55-
+o`"n3p&BO~>
+n,EI1GQ.%1#l5!Ds6qufj8ScP!rdDbf)GfmGQ-t/qu?dLr;QEi!rdDbdf0:fm/I>B,3Jp$!#55-
+o`"n3p&BO~>
+mf*;.amT06rr8g9J]Ifip&>'7*Rt)h*UNe+rql]qrq-3j*RXlgaERXPrs8Vu;ucn1FT;@5rrW1D
+aS#R`~>
+mf*;.amT06rr8g9J]Ifip&>'7*Rt)h*UNe+rql]qrq-3j*RXlgaERXPrs8Vu;ucn1FT;@5rrW1D
+aS#R`~>
+mf*;.amT06rr8g9J]Ifip&>'7*Rt)h*UNe+rql]qrq-3j*RXlgaERXPrs8Vu;ucn1FT;@5rrW1D
+aS#R`~>
+mJd/+gA_-me,KHj*SLGn*Qc\.!?K;MrrE&rrrE&jrrL4^o`'F~>
+mJd/+gA_-me,KHj*SLGn*Qc\.!?K;MrrE&rrrE&jrrL4^o`'F~>
+mJd/+gA_-me,KHj*SLGn*Qc\.!?K;MrrE&rrrE&jrrL4^o`'F~>
+mf*@fdN.-C!Zf_geGfXMGL?EGrr`8JGQ,qg!$'_m!$(V1J,~>
+mf*@fdN.-C!Zf_geGfXMGL?EGrr`8JGQ,qg!$'_m!$(V1J,~>
+mf*@fdN.-C!Zf_geGfXMGL?EGrr`8JGQ,qg!$'_m!$(V1J,~>
+mJd:fGL?EJrr`8JGQ-"i!?B5;rrL4]cMmtFdN.-C!Zf_go`'F~>
+mJd:fGL?EJrr`8JGQ-"i!?B5;rrL4]cMmtFdN.-C!Zf_go`'F~>
+mJd:fGL?EJrr`8JGQ-"i!?B5;rrL4]cMmtFdN.-C!Zf_go`'F~>
+li.#+df/8+!rgUfcMmkah>[Hpbl7eEGL?EJrr`8JGQ.46J,~>
+li.#+df/8+!rgUfcMmkah>[Hpbl7eEGL?EJrr`8JGQ.46J,~>
+li.#+df/8+!rgUfcMmkah>[Hpbl7eEGL?EJrr`8JGQ.46J,~>
+lMgl)dGk0,d2^I3!rgUfhu<`tdf.Gi!Z]Yfir9)ZdN%fWJ,~>
+lMgl)dGk0,d2^I3!rgUfhu<`tdf.Gi!Z]Yfir9)ZdN%fWJ,~>
+lMgl)dGk0,d2^I3!rgUfhu<`tdf.Gi!Z]Yfir9)ZdN%fWJ,~>
+l2Ld.*T[5$*I#a-"THghs8M-["TJE@df.Ag!?BMHrrLLenGe"~>
+l2Ld.*T[5$*I#a-"THghs8M-["TJE@df.Ag!?BMHrrLLenGe"~>
+l2Ld.*T[5$*I#a-"THghs8M-["TJE@df.Ag!?BMHrrLLenGe"~>
+l2LncdN&;dlMh"druBJdbPq_EaW/b.kPk\adN$C.a8Z0a*T[5$*I$uPJ,~>
+l2LncdN&;dlMh"druBJdbPq_EaW/b.kPk\adN$C.a8Z0a*T[5$*I$uPJ,~>
+l2LncdN&;dlMh"druBJdbPq_EaW/b.kPk\adN$C.a8Z0a*T[5$*I$uPJ,~>
+kl1hcaW5U*rpKdirr70_ao9?\!?BMMrrLLe`;]u>dN&;dlMh"druBJdn,In~>
+kl1hcaW5U*rpKdirr70_ao9?\!?BMMrrLLe`;]u>dN&;dlMh"druBJdn,In~>
+kl1hcaW5U*rpKdirr70_ao9?\!?BMMrrLLe`;]u>dN&;dlMh"druBJdn,In~>
+jo5J)*I%P_o)Ajls*#L)_uBd^*Q[RH!luC+_Z'f=aW5U*rpKdirr70_ao:`.J,~>
+jo5J)*I%P_o)Ajls*#L)_uBd^*Q[RH!luC+_Z'f=aW5U*rpKdirr70_ao:`.J,~>
+jo5J)*I%P_o)Ajls*#L)_uBd^*Q[RH!luC+_Z'f=aW5U*rpKdirr70_ao:`.J,~>
+j8T;(*I#U)rqQKsrr:&`*QZ(s"TJFF*Q[^L"NVU-s8Ke5"NVU-s8MTh"TJFF*Q[RHJ,~>
+j8T;(*I#U)rqQKsrr:&`*QZ(s"TJFF*Q[^L"NVU-s8Ke5"NVU-s8MTh"TJFF*Q[RHJ,~>
+j8T;(*I#U)rqQKsrr:&`*QZ(s"TJFF*Q[^L"NVU-s8Ke5"NVU-s8MTh"TJFF*Q[RHJ,~>
+i;Wpt*dDSDr;Qo@DKm4?]`/-6s*#N%oD\r2*d@Y`]Di&U*I#U)rqQKsrr:&`*Q[LFJ,~>
+i;Wpt*dDSDr;Qo@DKm4?]`/-6s*#N%oD\r2*d@Y`]Di&U*I#U)rqQKsrr:&`*Q[LFJ,~>
+i;Wpt*dDSDr;Qo@DKm4?]`/-6s*#N%oD\r2*d@Y`]Di&U*I#U)rqQKsrr:&`*Q[LFJ,~>
+h#@@lr,2RQ[f6R2s2]C*Df5IP#&\?#GKBg`[f6JJ*dDSDr;Qo@DKm4?k5Tr~>
+h#@@lr,2RQ[f6R2s2]C*Df5IP#&\?#GKBg`[f6JJ*dDSDr;Qo@DKm4?k5Tr~>
+h#@@lr,2RQ[f6R2s2]C*Df5IP#&\?#GKBg`[f6JJ*dDSDr;Qo@DKm4?k5Tr~>
+L]7MVs8U/XrGMgVaT);>YQ"T?r,2RQir=N~>
+L]7MVs8U/XrGMgVaT);>YQ"T?r,2RQir=N~>
+L]7MVs8U/XrGMgVaT);>YQ"T?r,2RQir=N~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+JcC<$J,~>
+%%EndData
+showpage
+%%Trailer
+end
+%%EOF
diff --git a/books/ps/v103openmathconnection.ps b/books/ps/v103openmathconnection.ps
new file mode 100644
index 0000000..6a4e4aa
--- /dev/null
+++ b/books/ps/v103openmathconnection.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 184 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 184 80
+%%PageOrientation: Portrait
+gsave
+36 36 148 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+146 42 lineto
+146 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+146 42 lineto
+146 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% OpenMathConnection
+[ /Rect [ 0 0 140 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OMCONN) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 140 36 moveto
+0 36 lineto
+0 0 lineto
+140 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 140 36 moveto
+0 36 lineto
+0 0 lineto
+140 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(OpenMathConnection)
+[10.08 6.96 6.24 6.96 12.48 6.24 4.08 6.96 9.36 6.96 6.96 6.96 6.24 6.24 3.84 3.84 6.96 6.96]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103openmathdevice.ps b/books/ps/v103openmathdevice.ps
new file mode 100644
index 0000000..9d65743
--- /dev/null
+++ b/books/ps/v103openmathdevice.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 160 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 160 80
+%%PageOrientation: Portrait
+gsave
+36 36 124 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+122 42 lineto
+122 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+122 42 lineto
+122 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% OpenMathDevice
+[ /Rect [ 0 0 116 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OMDEV) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 116 36 moveto
+0 36 lineto
+0 0 lineto
+116 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 116 36 moveto
+0 36 lineto
+0 0 lineto
+116 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(OpenMathDevice)
+[10.08 6.96 6.24 6.96 12.48 6.24 4.08 6.96 10.08 5.76 6.96 3.84 6.24 6.24]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103openmathencoding.ps b/books/ps/v103openmathencoding.ps
new file mode 100644
index 0000000..eb38124
--- /dev/null
+++ b/books/ps/v103openmathencoding.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 174 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 174 80
+%%PageOrientation: Portrait
+gsave
+36 36 138 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+136 42 lineto
+136 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+136 42 lineto
+136 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% OpenMathEncoding
+[ /Rect [ 0 0 130 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OMENC) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 130 36 moveto
+0 36 lineto
+0 0 lineto
+130 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 130 36 moveto
+0 36 lineto
+0 0 lineto
+130 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(OpenMathEncoding)
+[10.08 6.96 6.24 6.96 12.48 6.24 4.08 6.96 8.64 6.96 6.24 6.96 6.96 3.84 6.96 6.96]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103openmatherror.ps b/books/ps/v103openmatherror.ps
new file mode 100644
index 0000000..7ffc10d
--- /dev/null
+++ b/books/ps/v103openmatherror.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 150 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 150 80
+%%PageOrientation: Portrait
+gsave
+36 36 114 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+112 42 lineto
+112 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+112 42 lineto
+112 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% OpenMathError
+[ /Rect [ 0 0 106 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OMERR) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 106 36 moveto
+0 36 lineto
+0 0 lineto
+106 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 106 36 moveto
+0 36 lineto
+0 0 lineto
+106 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(OpenMathError)
+[10.08 6.96 6.24 6.96 12.48 6.24 4.08 6.96 8.64 5.28 4.8 6.96 4.8]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103openmatherrorkind.ps b/books/ps/v103openmatherrorkind.ps
new file mode 100644
index 0000000..4142274
--- /dev/null
+++ b/books/ps/v103openmatherrorkind.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 178 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 178 80
+%%PageOrientation: Portrait
+gsave
+36 36 142 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+140 42 lineto
+140 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+140 42 lineto
+140 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% OpenMathErrorKind
+[ /Rect [ 0 0 134 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OMERRK) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 134 36 moveto
+0 36 lineto
+0 0 lineto
+134 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 134 36 moveto
+0 36 lineto
+0 0 lineto
+134 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(OpenMathErrorKind)
+[10.08 6.96 6.24 6.96 12.48 6.24 4.08 6.96 8.64 5.28 4.8 6.96 4.8 9.84 3.84 6.96 6.96]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103operator.ps b/books/ps/v103operator.ps
new file mode 100644
index 0000000..4eed7a3
--- /dev/null
+++ b/books/ps/v103operator.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 154 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 154 80
+%%PageOrientation: Portrait
+gsave
+36 36 118 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+116 42 lineto
+116 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+116 42 lineto
+116 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% ModuleOperator
+[ /Rect [ 0 0 110 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=MODOP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 110 36 moveto
+0 36 lineto
+0 0 lineto
+110 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 110 36 moveto
+0 36 lineto
+0 0 lineto
+110 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(ModuleOperator)
+[12.48 6.96 6.96 6.96 3.84 6.24 10.08 6.96 6.24 4.8 6.24 3.84 6.96 4.8]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103outputform.ps b/books/ps/v103outputform.ps
new file mode 100644
index 0000000..d09d404
--- /dev/null
+++ b/books/ps/v103outputform.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 130 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 130 80
+%%PageOrientation: Portrait
+gsave
+36 36 94 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+92 42 lineto
+92 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+92 42 lineto
+92 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% OutputForm
+[ /Rect [ 0 0 86 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OUTFORM) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 86 36 moveto
+0 36 lineto
+0 0 lineto
+86 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 86 36 moveto
+0 36 lineto
+0 0 lineto
+86 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(OutputForm)
+[10.08 6.96 3.84 6.96 6.96 3.84 7.44 6.96 5.04 10.8]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103point.ps b/books/ps/v103point.ps
new file mode 100644
index 0000000..1740343
--- /dev/null
+++ b/books/ps/v103point.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 98 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 98 80
+%%PageOrientation: Portrait
+gsave
+36 36 62 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+60 42 lineto
+60 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+60 42 lineto
+60 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% Point
+[ /Rect [ 0 0 54 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=POINT) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 54 36 moveto
+0 36 lineto
+0 0 lineto
+54 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 54 36 moveto
+0 36 lineto
+0 0 lineto
+54 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+11 13 moveto
+(Point)
+[7.44 6.96 3.84 6.96 3.84]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103sparseunivariateskewpolynomial.ps b/books/ps/v103sparseunivariateskewpolynomial.ps
new file mode 100644
index 0000000..760196d
--- /dev/null
+++ b/books/ps/v103sparseunivariateskewpolynomial.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 250 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 250 80
+%%PageOrientation: Portrait
+gsave
+36 36 214 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+212 42 lineto
+212 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+212 42 lineto
+212 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% SparseUnivariateSkewPolynomial
+[ /Rect [ 0 0 206 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=ORESUP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 206 36 moveto
+0 36 lineto
+0 0 lineto
+206 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 206 36 moveto
+0 36 lineto
+0 0 lineto
+206 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(SparseUnivariateSkewPolynomial)
+[7.68 6.96 6.24 4.8 5.52 6.24 9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.68 6.72 5.76 10.08 7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103splittingnode.ps b/books/ps/v103splittingnode.ps
new file mode 100644
index 0000000..d1a714c
--- /dev/null
+++ b/books/ps/v103splittingnode.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 138 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 138 80
+%%PageOrientation: Portrait
+gsave
+36 36 102 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+100 42 lineto
+100 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+100 42 lineto
+100 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% SplittingNode
+[ /Rect [ 0 0 94 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=SPLNODE) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 94 36 moveto
+0 36 lineto
+0 0 lineto
+94 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 94 36 moveto
+0 36 lineto
+0 0 lineto
+94 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(SplittingNode)
+[7.68 6.96 3.84 3.84 3.84 3.84 3.84 6.96 6.96 9.84 6.96 6.96 6.24]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103splittingtree.ps b/books/ps/v103splittingtree.ps
new file mode 100644
index 0000000..c9b6ddb
--- /dev/null
+++ b/books/ps/v103splittingtree.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 134 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 134 80
+%%PageOrientation: Portrait
+gsave
+36 36 98 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+96 42 lineto
+96 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+96 42 lineto
+96 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% SplittingTree
+[ /Rect [ 0 0 90 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=SPLTREE) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 90 36 moveto
+0 36 lineto
+0 0 lineto
+90 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 90 36 moveto
+0 36 lineto
+0 0 lineto
+90 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(SplittingTree)
+[7.68 6.96 3.84 3.84 3.84 3.84 3.84 6.96 6.96 7.92 4.8 6.24 6.24]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103subspace.ps b/books/ps/v103subspace.ps
new file mode 100644
index 0000000..b17f928
--- /dev/null
+++ b/books/ps/v103subspace.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 116 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 116 80
+%%PageOrientation: Portrait
+gsave
+36 36 80 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+78 42 lineto
+78 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+78 42 lineto
+78 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% SubSpace
+[ /Rect [ 0 0 72 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=SUBSPACE) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 72 36 moveto
+0 36 lineto
+0 0 lineto
+72 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 72 36 moveto
+0 36 lineto
+0 0 lineto
+72 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(SubSpace)
+[7.68 6.96 6.96 7.68 6.96 6.24 6.24 6.24]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103subspacecomponentproperty.ps b/books/ps/v103subspacecomponentproperty.ps
new file mode 100644
index 0000000..bdfeebd
--- /dev/null
+++ b/books/ps/v103subspacecomponentproperty.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 228 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 228 80
+%%PageOrientation: Portrait
+gsave
+36 36 192 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+190 42 lineto
+190 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+190 42 lineto
+190 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% SubSpaceComponentProperty
+[ /Rect [ 0 0 184 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=COMPPROP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 184 36 moveto
+0 36 lineto
+0 0 lineto
+184 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 184 36 moveto
+0 36 lineto
+0 0 lineto
+184 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+7 13 moveto
+(SubSpaceComponentProperty)
+[7.68 6.96 6.96 7.68 6.96 6.24 6.24 6.24 9.36 6.96 10.56 6.96 6.96 6.96 6.24 6.96 3.84 7.68 4.8 6.96 6.96 6.24 5.04 3.84 6.96]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/books/ps/v103univariateskewpolynomial.ps b/books/ps/v103univariateskewpolynomial.ps
new file mode 100644
index 0000000..0509b9a
--- /dev/null
+++ b/books/ps/v103univariateskewpolynomial.ps
@@ -0,0 +1,248 @@
+%!PS-Adobe-2.0
+%%Creator: dot version 2.8 (Thu Sep 14 20:34:11 UTC 2006)
+%%For: (root) root
+%%Title: pic
+%%Pages: (atend)
+%%BoundingBox: 36 36 214 80
+%%EndComments
+save
+%%BeginProlog
+/DotDict 200 dict def
+DotDict begin
+
+/setupLatin1 {
+mark
+/EncodingVector 256 array def
+ EncodingVector 0
+
+ISOLatin1Encoding 0 255 getinterval putinterval
+EncodingVector 45 /hyphen put
+
+% Set up ISO Latin 1 character encoding
+/starnetISO {
+        dup dup findfont dup length dict begin
+        { 1 index /FID ne { def }{ pop pop } ifelse
+        } forall
+        /Encoding EncodingVector def
+        currentdict end definefont
+} def
+/Times-Roman starnetISO def
+/Times-Italic starnetISO def
+/Times-Bold starnetISO def
+/Times-BoldItalic starnetISO def
+/Helvetica starnetISO def
+/Helvetica-Oblique starnetISO def
+/Helvetica-Bold starnetISO def
+/Helvetica-BoldOblique starnetISO def
+/Courier starnetISO def
+/Courier-Oblique starnetISO def
+/Courier-Bold starnetISO def
+/Courier-BoldOblique starnetISO def
+cleartomark
+} bind def
+
+%%BeginResource: procset graphviz 0 0
+/coord-font-family /Times-Roman def
+/default-font-family /Times-Roman def
+/coordfont coord-font-family findfont 8 scalefont def
+
+/InvScaleFactor 1.0 def
+/set_scale {
+	dup 1 exch div /InvScaleFactor exch def
+	dup scale
+} bind def
+
+% styles
+/solid { [] 0 setdash } bind def
+/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def
+/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def
+/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def
+/bold { 2 setlinewidth } bind def
+/filled { } bind def
+/unfilled { } bind def
+/rounded { } bind def
+/diagonals { } bind def
+
+% hooks for setting color 
+/nodecolor { sethsbcolor } bind def
+/edgecolor { sethsbcolor } bind def
+/graphcolor { sethsbcolor } bind def
+/nopcolor {pop pop pop} bind def
+
+/beginpage {	% i j npages
+	/npages exch def
+	/j exch def
+	/i exch def
+	/str 10 string def
+	npages 1 gt {
+		gsave
+			coordfont setfont
+			0 0 moveto
+			(\() show i str cvs show (,) show j str cvs show (\)) show
+		grestore
+	} if
+} bind def
+
+/set_font {
+	findfont exch
+	scalefont setfont
+} def
+
+% draw aligned label in bounding box aligned to current point
+/alignedtext {			% width adj text
+	/text exch def
+	/adj exch def
+	/width exch def
+	gsave
+		width 0 gt {
+			text stringwidth pop adj mul 0 rmoveto
+		} if
+		[] 0 setdash
+		text show
+	grestore
+} def
+
+/boxprim {				% xcorner ycorner xsize ysize
+		4 2 roll
+		moveto
+		2 copy
+		exch 0 rlineto
+		0 exch rlineto
+		pop neg 0 rlineto
+		closepath
+} bind def
+
+/ellipse_path {
+	/ry exch def
+	/rx exch def
+	/y exch def
+	/x exch def
+	matrix currentmatrix
+	newpath
+	x y translate
+	rx ry scale
+	0 0 1 0 360 arc
+	setmatrix
+} bind def
+
+/endpage { showpage } bind def
+/showpage { } def
+
+/layercolorseq
+	[	% layer color sequence - darkest to lightest
+		[0 0 0]
+		[.2 .8 .8]
+		[.4 .8 .8]
+		[.6 .8 .8]
+		[.8 .8 .8]
+	]
+def
+
+/layerlen layercolorseq length def
+
+/setlayer {/maxlayer exch def /curlayer exch def
+	layercolorseq curlayer 1 sub layerlen mod get
+	aload pop sethsbcolor
+	/nodecolor {nopcolor} def
+	/edgecolor {nopcolor} def
+	/graphcolor {nopcolor} def
+} bind def
+
+/onlayer { curlayer ne {invis} if } def
+
+/onlayers {
+	/myupper exch def
+	/mylower exch def
+	curlayer mylower lt
+	curlayer myupper gt
+	or
+	{invis} if
+} def
+
+/curlayer 0 def
+
+%%EndResource
+%%EndProlog
+%%BeginSetup
+14 default-font-family set_font
+1 setmiterlimit
+% /arrowlength 10 def
+% /arrowwidth 5 def
+
+% make sure pdfmark is harmless for PS-interpreters other than Distiller
+/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+% make '<<' and '>>' safe on PS Level 1 devices
+/languagelevel where {pop languagelevel}{1} ifelse
+2 lt {
+    userdict (<<) cvn ([) cvn load put
+    userdict (>>) cvn ([) cvn load put
+} if
+
+%%EndSetup
+%%Page: 1 1
+%%PageBoundingBox: 36 36 214 80
+%%PageOrientation: Portrait
+gsave
+36 36 178 44 boxprim clip newpath
+36 36 translate
+0 0 1 beginpage
+1.0000 set_scale
+4 4 translate 0 rotate
+0.167 0.600 1.000 graphcolor
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+176 42 lineto
+176 -6 lineto
+closepath
+fill
+0.167 0.600 1.000 graphcolor
+newpath -6 -6 moveto
+-6 42 lineto
+176 42 lineto
+176 -6 lineto
+closepath
+stroke
+0.000 0.000 0.000 graphcolor
+14.00 /Times-Roman set_font
+% UnivariateSkewPolynomial
+[ /Rect [ 0 0 170 36 ]
+  /Border [ 0 0 0 ]
+  /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=OREUP) >>
+  /Subtype /Link
+/ANN pdfmark
+gsave 10 dict begin
+filled
+0.537 0.247 0.902 nodecolor
+0.537 0.247 0.902 nodecolor
+newpath 170 36 moveto
+0 36 lineto
+0 0 lineto
+170 0 lineto
+closepath
+fill
+0.537 0.247 0.902 nodecolor
+newpath 170 36 moveto
+0 36 lineto
+0 0 lineto
+170 0 lineto
+closepath
+stroke
+gsave 10 dict begin
+0.000 0.000 0.000 nodecolor
+8 13 moveto
+(UnivariateSkewPolynomial)
+[9.6 6.96 3.84 6.72 6.24 5.04 3.84 6.24 3.84 6.24 7.68 6.72 5.76 10.08 7.44 6.96 3.6 6.96 6.96 6.96 10.8 3.84 6.24 3.84]
+xshow
+end grestore
+end grestore
+endpage
+showpage
+grestore
+%%PageTrailer
+%%EndPage: 1
+%%Trailer
+%%Pages: 1
+end
+restore
+%%EOF
diff --git a/changelog b/changelog
index b949a12..4fe3151 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,52 @@
+20081212 tpd src/axiom-website/patches.html 20081212.01.tpd.patch
+20081212 tpd books/bookvol4.pamphlet added
+20081212 tpd books/ps/v103univariateskewpolynomial.ps added
+20081212 tpd books/ps/v103subspacecomponentproperty.ps added
+20081212 tpd books/ps/v103subspace.ps added
+20081212 tpd books/ps/v103splittingtree.ps added
+20081212 tpd books/ps/v103splittingnode.ps added
+20081212 tpd books/ps/v103sparseunivariateskewpolynomial.ps added
+20081212 tpd books/ps/v103point.ps added
+20081212 tpd books/ps/v103outputform.ps added
+20081212 tpd books/ps/v103operator.ps added
+20081212 tpd books/ps/v103openmatherrorkind.ps added
+20081212 tpd books/ps/v103openmatherror.ps added
+20081212 tpd books/ps/v103openmathencoding.ps added
+20081212 tpd books/ps/v103openmathdevice.ps added
+20081212 tpd books/ps/v103openmathconnection.ps added
+20081212 tpd books/ps/v103octoniongraph.eps added
+20081212 tpd books/ps/v103octonion.ps added
+20081212 tpd books/ps/v103newsparseunivariatepolynomial.ps added
+20081212 tpd books/ps/v103newsparsemultivariatepolynomial.ps added
+20081212 tpd books/ps/v103moduleoperator.ps added
+20081212 tpd books/ps/v103basicoperator.ps added
+20081212 tpd books/ps/v103automorphism.ps added
+20081212 tpd books/ps/v103algebragivenbystructuralconstants.ps added
+20081212 tpd src/algebra/Makefile fixup help files
+20081212 tpd src/algebra/outform.spad move domain to bookvol10.3
+20081212 tpd src/algebra/ore.spad move domains to bookvol10.3
+20081212 tpd src/algebra/op.spad move domain to bookvol10.3
+20081212 tpd src/algebra/Makefile remove opalg.spad
+20081212 tpd src/algebra/opalg.spad removed, move domains to bookvol10.3
+20081212 tpd src/algebra/Makefile remove omerror.spad
+20081212 tpd src/algebra/omerror.spad removed, move domains to bookvol10.3
+20081212 tpd src/algebra/omdev.spad move domains to bookvol10.3
+20081212 tpd src/algebra/oct.spad move domain to bookvol10.3
+20081212 tpd src/algebra/newpoly.spad move domains to bookvol10.3
+20081212 tpd src/algebra/newpoint.spad move domains to bookvol10.3
+20081212 tpd src/algebra/newdata.spad move domains to bookvol10.3
+20081212 tpd src/algebra/naalg.spad move domain to bookvol10.3
+20081211 tpd src/axiom-website/patches.html 20081211.01.tpd.patch
+20081211 tpd src/input/series.input fix mismatched chunk
+20081211 tpd src/input/cwmmt.input copy source file to int/input
+20081211 tpd books/bookvol10.3 clean up input file for lodo
+20081211 tpd src/algebra/acplot.spad remove duplicate )spool
+20081211 tpd src/algebra/mappkg.spad remove duplicate )spool
+20081211 tpd src/algebra/xlpoly.spad remove duplicate )spool
+20081211 tpd src/input/function.input add )spool
+20081211 tpd src/input/Makefile remove xpbwpoly.input
+20081211 tpd src/input/xpbwpoly.input removed, duplicate in bookvol10.3
+20081210 tpd src/axiom-website/patches.html 20081210.01.tpd.patch
 20081210 tpd src/input/test.input fix reference to multpoly.spad
 20081210 tpd books/Makefile set SHELL to bash to fix echo behavior in toc
 20081210 tpd src/algebra/multpoly.spad moved domains to bookvol10.3
diff --git a/src/algebra/Makefile.pamphlet b/src/algebra/Makefile.pamphlet
index 8c74041..16cf251 100644
--- a/src/algebra/Makefile.pamphlet
+++ b/src/algebra/Makefile.pamphlet
@@ -368,7 +368,6 @@ drawpak.spad.pamphlet (DRAWCX)
 mappkg.spad.pamphlet (MAPHACK1 MAPHACK2 MAPHACK3 MAPHACK4
                       MAPPKG1 MAPPKG2 MAPPKG3 MAPPKG4)
 mesh.spad.pamphlet (MESH)
-opalg.spad.pamphlet (MODOP OP)
 partperm.spad.pamphlet (PARTPERM)
 pgrobner.spad.pamphlet (PGROEB)
 plottool.spad.pamphlet (PLOTTOOL)
@@ -755,7 +754,6 @@ mkfunc.spad.pamphlet (INFORM INFORM1 MKFUNC MKUCFUNC MKBCFUNC MKFLCFN)
 modgcd.spad.pamphlet (INMODGCD)
 multpoly.spad.pamphlet (POLY POLY2 MPOLY SMP INDE)
 newdata.spad.pamphlet (IPRNTPK TBCMPPK SPLNODE SPLTREE)
-omerror.spad.pamphlet (OMERRK OMERR)
 op.spad.pamphlet (BOP BOP1 COMMONOP)
 out.spad.pamphlet (OUT SPECOUT DISPLAY)
 outform.spad.pamphlet (NUMFMT OUTFORM)
@@ -1192,7 +1190,7 @@ SPADFILES= \
  ${OUTSRC}/numtheor.spad \
  ${OUTSRC}/oct.spad ${OUTSRC}/odealg.spad ${OUTSRC}/odeef.spad \
  ${OUTSRC}/oderf.spad ${OUTSRC}/omdev.spad \
- ${OUTSRC}/omerror.spad ${OUTSRC}/omserver.spad ${OUTSRC}/opalg.spad \
+ ${OUTSRC}/omserver.spad \
  ${OUTSRC}/openmath.spad ${OUTSRC}/op.spad ${OUTSRC}/ore.spad \
  ${OUTSRC}/outform.spad ${OUTSRC}/out.spad \
  ${OUTSRC}/pade.spad ${OUTSRC}/padiclib.spad ${OUTSRC}/padic.spad \
@@ -1346,7 +1344,7 @@ DOCFILES= \
  ${DOC}/numtheor.spad.dvi \
  ${DOC}/oct.spad.dvi ${DOC}/odealg.spad.dvi ${DOC}/odeef.spad.dvi \
  ${DOC}/oderf.spad.dvi ${DOC}/omdev.spad.dvi \
- ${DOC}/omerror.spad.dvi ${DOC}/omserver.spad.dvi ${DOC}/opalg.spad.dvi \
+ ${DOC}/omserver.spad.dvi \
  ${DOC}/openmath.spad.dvi ${DOC}/op.spad.dvi ${DOC}/ore.spad.dvi \
  ${DOC}/outform.spad.dvi ${DOC}/out.spad.dvi \
  ${DOC}/pade.spad.dvi ${DOC}/padiclib.spad.dvi ${DOC}/padic.spad.dvi \
@@ -2153,12 +2151,12 @@ ${HELP}/BalancedBinaryTree.help: ${IN}/tree.spad.pamphlet
 	@${TANGLE} -R"BalancedBinaryTree.input" ${IN}/tree.spad.pamphlet \
             >${INPUT}/BalancedBinaryTree.input
 
-${HELP}/BasicOperator.help: ${IN}/op.spad.pamphlet
-	@echo 7002 create BasicOperator.help from ${IN}/op.spad.pamphlet
-	@${TANGLE} -R"BasicOperator.help" ${IN}/op.spad.pamphlet \
+${HELP}/BasicOperator.help: ${BOOKS}/bookvol10.3.pamphlet
+	@echo 7002 create BasicOperator.help from ${BOOKS}/bookvol10.3.pamphlet
+	@${TANGLE} -R"BasicOperator.help" ${BOOKS}/bookvol10.3.pamphlet \
             >${HELP}/BasicOperator.help
 	@cp ${HELP}/BasicOperator.help ${HELP}/BOP.help
-	@${TANGLE} -R"BasicOperator.input" ${IN}/op.spad.pamphlet \
+	@${TANGLE} -R"BasicOperator.input" ${BOOKS}/bookvol10.3.pamphlet \
             >${INPUT}/BasicOperator.input
 
 ${HELP}/BinaryExpansion.help: ${IN}/radix.spad.pamphlet
@@ -2643,12 +2641,12 @@ ${HELP}/None.help: ${BOOKS}/bookvol10.3.pamphlet
 	@${TANGLE} -R"None.input" ${BOOKS}/bookvol10.3.pamphlet \
              >${INPUT}/None.input
 
-${HELP}/Octonion.help: ${IN}/oct.spad.pamphlet
-	@echo 7056 create Octonion.help from ${IN}/oct.spad.pamphlet
-	@${TANGLE} -R"Octonion.help" ${IN}/oct.spad.pamphlet \
+${HELP}/Octonion.help: ${BOOKS}/bookvol10.3.pamphlet
+	@echo 7056 create Octonion.help from ${BOOKS}/bookvol10.3.pamphlet
+	@${TANGLE} -R"Octonion.help" ${BOOKS}/bookvol10.3.pamphlet \
            >${HELP}/Octonion.help
 	@cp ${HELP}/Octonion.help ${HELP}/OCT.help
-	@${TANGLE} -R"Octonion.input" ${IN}/oct.spad.pamphlet \
+	@${TANGLE} -R"Octonion.input" ${BOOKS}/bookvol10.3.pamphlet \
             >${INPUT}/Octonion.input
 
 ${HELP}/OneDimensionalArray.help: ${BOOKS}/bookvol10.3.pamphlet
@@ -2661,12 +2659,12 @@ ${HELP}/OneDimensionalArray.help: ${BOOKS}/bookvol10.3.pamphlet
             ${BOOKS}/bookvol10.3.pamphlet \
             >${INPUT}/OneDimensionalArray.input
 
-${HELP}/Operator.help: ${IN}/opalg.spad.pamphlet
-	@echo 7058 create Operator.help from ${IN}/opalg.spad.pamphlet
-	@${TANGLE} -R"Operator.help" ${IN}/opalg.spad.pamphlet \
+${HELP}/Operator.help: ${BOOKS}/bookvol10.3.pamphlet
+	@echo 7058 create Operator.help from ${BOOKS}/bookvol10.3.pamphlet
+	@${TANGLE} -R"Operator.help" ${BOOKS}/bookvol10.3.pamphlet \
            >${HELP}/Operator.help
 	@cp ${HELP}/Operator.help ${HELP}/OP.help
-	@${TANGLE} -R"Operator.input" ${IN}/opalg.spad.pamphlet \
+	@${TANGLE} -R"Operator.input" ${BOOKS}/bookvol10.3.pamphlet \
             >${INPUT}/Operator.input
 
 ${HELP}/OrderedVariableList.help: ${IN}/variable.spad.pamphlet
diff --git a/src/algebra/naalg.spad.pamphlet b/src/algebra/naalg.spad.pamphlet
index ec93ce5..d70c989 100644
--- a/src/algebra/naalg.spad.pamphlet
+++ b/src/algebra/naalg.spad.pamphlet
@@ -9,396 +9,6 @@
 \eject
 \tableofcontents
 \eject
-\section{domain ALGSC AlgebraGivenByStructuralConstants}
-<<domain ALGSC AlgebraGivenByStructuralConstants>>=
-)abbrev domain ALGSC AlgebraGivenByStructuralConstants
-++ Authors: J. Grabmeier, R. Wisbauer
-++ Date Created: 01 March 1991
-++ Date Last Updated: 22 January 1992
-++ Basic Operations:
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
-++ Keywords: algebra, structural constants
-++ Reference:
-++  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(R:Field, n : PositiveInteger,_
-  ls : List Symbol, gamma: Vector Matrix R ): public == private where
-
-  V  ==> Vector
-  M  ==> Matrix
-  I  ==> Integer
-  NNI  ==> NonNegativeInteger
-  REC  ==> Record(particular: Union(V R,"failed"),basis: List V R)
-  LSMP ==> LinearSystemMatrixPackage(R,V R,V R, M R)
-
-  --public ==> FramedNonAssociativeAlgebra(R) with
-  public ==> Join(FramedNonAssociativeAlgebra(R), _
-    LeftModule(SquareMatrix(n,R)) ) with
-
-    coerce : Vector R -> %
-      ++ coerce(v) converts a vector to a member of the algebra
-      ++ by forming a linear combination with the basis element.
-      ++ Note: the vector is assumed to have length equal to the
-      ++ dimension of the algebra.
-
-  private ==> DirectProduct(n,R) add
-
-    Rep := DirectProduct(n,R)
-
-    x,y : %
-    dp : DirectProduct(n,R)
-    v : V R
-
-
-    recip(x) == recip(x)$FiniteRankNonAssociativeAlgebra_&(%,R)
-
-    (m:SquareMatrix(n,R))*(x:%) == apply((m :: Matrix R),x)
-    coerce v == directProduct(v) :: %
-
-    structuralConstants() == gamma
-
-    coordinates(x) == vector(entries(x :: Rep)$Rep)$Vector(R)
-
-    coordinates(x,b) ==
-      --not (maxIndex b = n) =>
-      --  error("coordinates: your 'basis' has not the right length")
-      m : NonNegativeInteger := (maxIndex b) :: NonNegativeInteger
-      transitionMatrix   : Matrix R := new(n,m,0$R)$Matrix(R)
-      for i in 1..m repeat
-        setColumn_!(transitionMatrix,i,coordinates(b.i))
-      res : REC := solve(transitionMatrix,coordinates(x))$LSMP
-      if (not every?(zero?$R,first res.basis)) then
-        error("coordinates: warning your 'basis' is linearly dependent")
-      (res.particular  case "failed") =>
-        error("coordinates: first argument is not in linear span of second argument")
-      (res.particular) :: (Vector R)
-
-    basis() == [unitVector(i::PositiveInteger)::% for i in 1..n]
-
-    someBasis() == basis()$%
-
-    rank() == n
-
-    elt(x,i) == elt(x:Rep,i)$Rep
-
-    coerce(x:%):OutputForm ==
-      zero?(x::Rep)$Rep => (0$R) :: OutputForm
-      le : List OutputForm := nil
-      for i in 1..n repeat
-        coef : R := elt(x::Rep,i)
-        not zero?(coef)$R =>
---          one?(coef)$R =>
-          ((coef) = 1)$R =>
-            -- sy : OutputForm := elt(ls,i)$(List Symbol) :: OutputForm
-            le := cons(elt(ls,i)$(List Symbol) :: OutputForm, le)
-          le := cons(coef :: OutputForm *  elt(ls,i)$(List Symbol)_
-              :: OutputForm, le)
-      reduce("+",le)
-
-    x * y ==
-      v : Vector R :=  new(n,0)
-      for k in 1..n repeat
-        h : R := 0
-        for i in 1..n repeat
-          for j in 1..n repeat
-            h := h  +$R elt(x,i) *$R elt(y,j) *$R elt(gamma.k,i,j )
-        v.k := h
-      directProduct v
-
-
-
-    alternative?() ==
-      for i in 1..n repeat
-        -- expression for check of left alternative is symmetric in i and j:
-        -- expression for check of right alternative is symmetric in j and k:
-        for j in 1..i-1 repeat
-          for k in j..n repeat
-            -- right check
-            for r in 1..n repeat
-              res := 0$R
-              for l in 1..n repeat
-                res := res - _
-                  (elt(gamma.l,j,k)+elt(gamma.l,k,j))*elt(gamma.r,i,l)+_
-                  (elt(gamma.l,i,j)*elt(gamma.r,l,k) + elt(gamma.l,i,k)*_
-                  elt(gamma.r,l,j) )
-              not zero? res =>
-                messagePrint("algebra is not right alternative")$OutputForm
-                return false
-        for j in i..n repeat
-          for k in 1..j-1 repeat
-            -- left check
-            for r in 1..n repeat
-              res := 0$R
-              for l in 1..n repeat
-                res := res + _
-                  (elt(gamma.l,i,j)+elt(gamma.l,j,i))*elt(gamma.r,l,k)-_
-                  (elt(gamma.l,j,k)*elt(gamma.r,i,l) + elt(gamma.l,i,k)*_
-                   elt(gamma.r,j,l) )
-              not (zero? res) =>
-                messagePrint("algebra is not left alternative")$OutputForm
-                return false
-
-          for k in j..n repeat
-            -- left check
-            for r in 1..n repeat
-              res := 0$R
-              for l in 1..n repeat
-                res := res + _
-                  (elt(gamma.l,i,j)+elt(gamma.l,j,i))*elt(gamma.r,l,k)-_
-                  (elt(gamma.l,j,k)*elt(gamma.r,i,l) + elt(gamma.l,i,k)*_
-                   elt(gamma.r,j,l) )
-              not (zero? res) =>
-                messagePrint("algebra is not left alternative")$OutputForm
-                return false
-            -- right check
-            for r in 1..n repeat
-              res := 0$R
-              for l in 1..n repeat
-                res := res - _
-                  (elt(gamma.l,j,k)+elt(gamma.l,k,j))*elt(gamma.r,i,l)+_
-                  (elt(gamma.l,i,j)*elt(gamma.r,l,k) + elt(gamma.l,i,k)*_
-                  elt(gamma.r,l,j) )
-              not (zero? res) =>
-                messagePrint("algebra is not right alternative")$OutputForm
-                return false
-
-      messagePrint("algebra satisfies 2*associator(a,b,b) = 0 = 2*associator(a,a,b) = 0")$OutputForm
-      true
-
-    -- should be in the category, but is not exported
---    conditionsForIdempotents b  ==
---      n := rank()
---      --gamma : Vector Matrix R := structuralConstants b
---      listOfNumbers : List String :=  [STRINGIMAGE(q)$Lisp for q in 1..n]
---      symbolsForCoef : Vector Symbol :=
---        [concat("%", concat("x", i))::Symbol  for i in listOfNumbers]
---      conditions : List Polynomial R := []
- --     for k in 1..n repeat
- --       xk := symbolsForCoef.k
- --       p : Polynomial R :=  monomial( - 1$Polynomial(R), [xk], [1] )
- --       for i in 1..n repeat
- --         for j in 1..n repeat
- --           xi := symbolsForCoef.i
- --           xj := symbolsForCoef.j
- --           p := p + monomial(_
- --             elt((gamma.k),i,j) :: Polynomial(R), [xi,xj], [1,1])
- --       conditions := cons(p,conditions)
- --     conditions
-
-    associative?() ==
-      for i in 1..n repeat
-       for j in 1..n repeat
-        for k in 1..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-             res := res + elt(gamma.l,i,j)*elt(gamma.r,l,k)-_
-                          elt(gamma.l,j,k)*elt(gamma.r,i,l)
-           not (zero? res) =>
-            messagePrint("algebra is not associative")$OutputForm
-            return false
-      messagePrint("algebra is associative")$OutputForm
-      true
-
-
-    antiAssociative?() ==
-      for i in 1..n repeat
-       for j in 1..n repeat
-        for k in 1..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-             res := res + elt(gamma.l,i,j)*elt(gamma.r,l,k)+_
-                          elt(gamma.l,j,k)*elt(gamma.r,i,l)
-           not (zero? res) =>
-            messagePrint("algebra is not anti-associative")$OutputForm
-            return false
-      messagePrint("algebra is anti-associative")$OutputForm
-      true
-
-    commutative?() ==
-      for i in 1..n repeat
-       for j in (i+1)..n repeat
-        for k in 1..n repeat
-           not ( elt(gamma.k,i,j)=elt(gamma.k,j,i) ) =>
-            messagePrint("algebra is not commutative")$OutputForm
-            return false
-      messagePrint("algebra is commutative")$OutputForm
-      true
-
-    antiCommutative?() ==
-      for i in 1..n repeat
-       for j in i..n repeat
-        for k in 1..n repeat
-          not zero? (i=j => elt(gamma.k,i,i); elt(gamma.k,i,j)+elt(gamma.k,j,i) ) =>
-            messagePrint("algebra is not anti-commutative")$OutputForm
-            return false
-      messagePrint("algebra is anti-commutative")$OutputForm
-      true
-
-    leftAlternative?() ==
-      for i in 1..n repeat
-       -- expression is symmetric in i and j:
-       for j in i..n repeat
-        for k in 1..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-             res := res + (elt(gamma.l,i,j)+elt(gamma.l,j,i))*elt(gamma.r,l,k)-_
-               (elt(gamma.l,j,k)*elt(gamma.r,i,l) + elt(gamma.l,i,k)*elt(gamma.r,j,l) )
-           not (zero? res) =>
-            messagePrint("algebra is not left alternative")$OutputForm
-            return false
-      messagePrint("algebra is left alternative")$OutputForm
-      true
-
-
-    rightAlternative?() ==
-      for i in 1..n repeat
-       for j in 1..n repeat
-       -- expression is symmetric in j and k:
-        for k in j..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-             res := res - (elt(gamma.l,j,k)+elt(gamma.l,k,j))*elt(gamma.r,i,l)+_
-               (elt(gamma.l,i,j)*elt(gamma.r,l,k) + elt(gamma.l,i,k)*elt(gamma.r,l,j) )
-           not (zero? res) =>
-            messagePrint("algebra is not right alternative")$OutputForm
-            return false
-      messagePrint("algebra is right alternative")$OutputForm
-      true
-
-
-    flexible?() ==
-      for i in 1..n repeat
-       for j in 1..n repeat
-       -- expression is symmetric in i and k:
-        for k in i..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-             res := res + elt(gamma.l,i,j)*elt(gamma.r,l,k)-_
-                          elt(gamma.l,j,k)*elt(gamma.r,i,l)+_
-                          elt(gamma.l,k,j)*elt(gamma.r,l,i)-_
-                          elt(gamma.l,j,i)*elt(gamma.r,k,l)
-           not (zero? res) =>
-            messagePrint("algebra is not flexible")$OutputForm
-            return false
-      messagePrint("algebra is flexible")$OutputForm
-      true
-
-    lieAdmissible?() ==
-      for i in 1..n repeat
-       for j in 1..n repeat
-        for k in 1..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-             res := res_
-              + (elt(gamma.l,i,j)-elt(gamma.l,j,i))*(elt(gamma.r,l,k)-elt(gamma.r,k,l)) _
-              + (elt(gamma.l,j,k)-elt(gamma.l,k,j))*(elt(gamma.r,l,i)-elt(gamma.r,i,l)) _
-              + (elt(gamma.l,k,i)-elt(gamma.l,i,k))*(elt(gamma.r,l,j)-elt(gamma.r,j,l))
-           not (zero? res) =>
-            messagePrint("algebra is not Lie admissible")$OutputForm
-            return false
-      messagePrint("algebra is Lie admissible")$OutputForm
-      true
-
-    jordanAdmissible?()  ==
-      recip(2 * 1$R) case "failed" =>
-        messagePrint("this algebra is not Jordan admissible, as 2 is not invertible in the ground ring")$OutputForm
-        false
-      for i in 1..n repeat
-       for j in 1..n repeat
-        for k in 1..n repeat
-         for w in 1..n repeat
-          for t in 1..n repeat
-           res := 0$R
-           for l in 1..n repeat
-            for r in 1..n repeat
-             res := res_
-              + (elt(gamma.l,i,j)+elt(gamma.l,j,i))_
-                * (elt(gamma.r,w,k)+elt(gamma.r,k,w))_
-                * (elt(gamma.t,l,r)+elt(gamma.t,r,l))_
-              - (elt(gamma.r,w,k)+elt(gamma.r,k,w))_
-                * (elt(gamma.l,j,r)+elt(gamma.l,r,j))_
-                * (elt(gamma.t,i,l)+elt(gamma.t,l,i))_
-              + (elt(gamma.l,w,j)+elt(gamma.l,j,w))_
-                * (elt(gamma.r,k,i)+elt(gamma.r,i,k))_
-                * (elt(gamma.t,l,r)+elt(gamma.t,r,l))_
-              - (elt(gamma.r,k,i)+elt(gamma.r,k,i))_
-                * (elt(gamma.l,j,r)+elt(gamma.l,r,j))_
-                * (elt(gamma.t,w,l)+elt(gamma.t,l,w))_
-              + (elt(gamma.l,k,j)+elt(gamma.l,j,k))_
-                * (elt(gamma.r,i,w)+elt(gamma.r,w,i))_
-                * (elt(gamma.t,l,r)+elt(gamma.t,r,l))_
-              - (elt(gamma.r,i,w)+elt(gamma.r,w,i))_
-                * (elt(gamma.l,j,r)+elt(gamma.l,r,j))_
-                * (elt(gamma.t,k,l)+elt(gamma.t,l,k))
-           not (zero? res) =>
-             messagePrint("algebra is not Jordan admissible")$OutputForm
-             return false
-      messagePrint("algebra is Jordan admissible")$OutputForm
-      true
-
-    jordanAlgebra?()  ==
-      recip(2 * 1$R) case "failed" =>
-        messagePrint("this is not a Jordan algebra, as 2 is not invertible in the ground ring")$OutputForm
-        false
-      not commutative?() =>
-        messagePrint("this is not a Jordan algebra")$OutputForm
-        false
-      for i in 1..n repeat
-       for j in 1..n repeat
-        for k in 1..n repeat
-         for l in 1..n repeat
-           for t in 1..n repeat
-             res := 0$R
-             for r in 1..n repeat
-               for s in 1..n repeat
-                 res := res +  _
-                   elt(gamma.r,i,j)*elt(gamma.s,l,k)*elt(gamma.t,r,s) - _
-                   elt(gamma.r,l,k)*elt(gamma.s,j,r)*elt(gamma.t,i,s) + _
-                   elt(gamma.r,l,j)*elt(gamma.s,k,k)*elt(gamma.t,r,s) - _
-                   elt(gamma.r,k,i)*elt(gamma.s,j,r)*elt(gamma.t,l,s) + _
-                   elt(gamma.r,k,j)*elt(gamma.s,i,k)*elt(gamma.t,r,s) - _
-                   elt(gamma.r,i,l)*elt(gamma.s,j,r)*elt(gamma.t,k,s)
-                 not zero? res =>
-                   messagePrint("this is not a Jordan algebra")$OutputForm
-                   return false
-      messagePrint("this is a Jordan algebra")$OutputForm
-      true
-
-
-    jacobiIdentity?()  ==
-      for i in 1..n repeat
-       for j in 1..n repeat
-        for k in 1..n repeat
-         for r in 1..n repeat
-           res := 0$R
-           for s in 1..n repeat
-                 res := res +  elt(gamma.r,i,j)*elt(gamma.s,j,k) +_
-                               elt(gamma.r,j,k)*elt(gamma.s,k,i) +_
-                               elt(gamma.r,k,i)*elt(gamma.s,i,j)
-           not zero? res =>
-                 messagePrint("Jacobi identity does not hold")$OutputForm
-                 return false
-      messagePrint("Jacobi identity holds")$OutputForm
-      true
-
-@
 \section{package SCPKG StructuralConstantsPackage}
 <<package SCPKG StructuralConstantsPackage>>=
 )abbrev package SCPKG StructuralConstantsPackage
@@ -1083,7 +693,6 @@ Gregory Vanuxem supplied the fix below.
 <<*>>=
 <<license>>
 
-<<domain ALGSC AlgebraGivenByStructuralConstants>>
 <<package ALGPKG AlgebraPackage>>
 <<package SCPKG StructuralConstantsPackage>>
 <<package FRNAAF2 FramedNonAssociativeAlgebraFunctions2>>
diff --git a/src/algebra/newdata.spad.pamphlet b/src/algebra/newdata.spad.pamphlet
index 29e9f6a..018f81f 100644
--- a/src/algebra/newdata.spad.pamphlet
+++ b/src/algebra/newdata.spad.pamphlet
@@ -178,466 +178,6 @@ TabulatedComputationPackage(Key ,Entry): Exports == Implementation where
        void()
 
 @
-\section{domain SPLNODE SplittingNode}
-<<domain SPLNODE SplittingNode>>=
-)abbrev domain SPLNODE SplittingNode
-++ Author: Marc Moereno Maza
-++ Date Created: 07/05/1996
-++ Date Last Updated:  07/19/1996
-++ Basic Functions:
-++ Related Constructors:
-++ Also See: 
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++ References:
-++ Description: 
-++    This domain exports a modest implementation for the
-++    vertices of splitting trees. These vertices are called
-++    here splitting nodes. Every of these nodes store 3 informations. 
-++    The first one is its value, that is the current expression 
-++    to evaluate. The second one is its condition, that is the 
-++    hypothesis under which the value has to be evaluated. 
-++    The last one is its status, that is a boolean flag
-++    which is true iff the value is the result of its
-++    evaluation under its condition. Two splitting vertices
-++    are equal iff they have the sane values and the same
-++    conditions (so their status do not matter).
-
-SplittingNode(V,C) : Exports == Implementation where
-
-  V:Join(SetCategory,Aggregate)
-  C:Join(SetCategory,Aggregate)
-  Z ==> Integer
-  B ==> Boolean
-  O ==> OutputForm
-  VT ==> Record(val:V, tower:C)
-  VTB ==> Record(val:V, tower:C, flag:B)
-
-  Exports ==  SetCategory with
-
-     empty : () -> %
-       ++ \axiom{empty()} returns the same as 
-       ++ \axiom{[empty()$V,empty()$C,false]$%}
-     empty? : % -> B
-       ++ \axiom{empty?(n)} returns true iff the node n is \axiom{empty()$%}.
-     value : % -> V
-       ++ \axiom{value(n)} returns the value of the node n.
-     condition : % -> C
-       ++ \axiom{condition(n)} returns the condition of the node n.
-     status : % -> B
-       ++ \axiom{status(n)} returns the status of the node n.
-     construct : (V,C,B) -> %
-       ++ \axiom{construct(v,t,b)} returns the non-empty node with
-       ++ value v, condition t and flag b
-     construct : (V,C) -> %
-       ++ \axiom{construct(v,t)} returns the same as
-       ++ \axiom{construct(v,t,false)}
-     construct : VT ->  %
-       ++ \axiom{construct(vt)} returns the same as
-       ++ \axiom{construct(vt.val,vt.tower)}
-     construct : List VT ->  List %
-       ++ \axiom{construct(lvt)} returns the same as
-       ++ \axiom{[construct(vt.val,vt.tower) for vt in lvt]}
-     construct : (V, List C) -> List %
-       ++ \axiom{construct(v,lt)} returns the same as
-       ++ \axiom{[construct(v,t) for t in lt]}
-     copy : % -> %
-       ++ \axiom{copy(n)} returns a copy of n.
-     setValue! : (%,V) -> %
-       ++ \axiom{setValue!(n,v)} returns n whose value
-       ++ has been replaced by v if it is not 
-       ++ empty, else an error is produced.
-     setCondition! : (%,C) -> %
-       ++ \axiom{setCondition!(n,t)} returns n whose condition
-       ++ has been replaced by t if it is not 
-       ++ empty, else an error is produced.
-     setStatus!: (%,B) -> %
-       ++ \axiom{setStatus!(n,b)} returns n whose status
-       ++ has been replaced by b if it is not 
-       ++ empty, else an error is produced.
-     setEmpty! : % -> %
-       ++ \axiom{setEmpty!(n)} replaces n by \axiom{empty()$%}.
-     infLex? : (%,%,(V,V) -> B,(C,C) -> B) -> B
-       ++ \axiom{infLex?(n1,n2,o1,o2)} returns true iff
-       ++ \axiom{o1(value(n1),value(n2))} or
-       ++ \axiom{value(n1) = value(n2)} and
-       ++ \axiom{o2(condition(n1),condition(n2))}.
-     subNode? : (%,%,(C,C) -> B) -> B
-       ++ \axiom{subNode?(n1,n2,o2)} returns true iff
-       ++ \axiom{value(n1) = value(n2)} and
-       ++ \axiom{o2(condition(n1),condition(n2))}
-
-  Implementation == add
-
-     Rep ==> VTB
-
-     rep(n:%):Rep == n pretend Rep
-     per(r:Rep):% == r pretend %
-
-     empty() == per [empty()$V,empty()$C,false]$Rep
-     empty?(n:%) == empty?((rep n).val)$V and  empty?((rep n).tower)$C
-     value(n:%) == (rep n).val
-     condition(n:%) == (rep n).tower
-     status(n:%) == (rep n).flag
-     construct(v:V,t:C,b:B) ==  per [v,t,b]$Rep
-     construct(v:V,t:C) == [v,t,false]$%
-     construct(vt:VT) == [vt.val,vt.tower]$%
-     construct(lvt:List VT) == [[vt]$% for vt in lvt]
-     construct(v:V,lt: List C) == [[v,t]$% for t in lt]
-     copy(n:%) == per copy rep n
-     setValue!(n:%,v:V) == 
-        (rep n).val := v
-        n
-     setCondition!(n:%,t:C) ==
-        (rep n).tower := t
-        n
-     setStatus!(n:%,b:B) ==
-        (rep n).flag := b
-        n
-     setEmpty!(n:%) ==
-        (rep n).val := empty()$V
-        (rep n).tower := empty()$C
-        n
-     infLex?(n1,n2,o1,o2) ==
-        o1((rep n1).val,(rep n2).val) => true
-        (rep n1).val = (rep n2).val => 
-           o2((rep n1).tower,(rep n2).tower)
-        false
-     subNode?(n1,n2,o2) ==
-        (rep n1).val = (rep n2).val => 
-           o2((rep n1).tower,(rep n2).tower)
-        false
-     -- sample() == empty()
-     n1:% = n2:% ==
-        (rep n1).val ~= (rep n2).val => false
-        (rep n1).tower = (rep n2).tower
-     n1:% ~= n2:% ==
-        (rep n1).val = (rep n2).val => false
-        (rep n1).tower ~= (rep n2).tower
-     coerce(n:%):O ==
-        l1,l2,l3,l : List O
-        l1 := [message("value == "), ((rep n).val)::O]
-        o1 : O := blankSeparate l1
-        l2 := [message(" tower == "), ((rep n).tower)::O]
-        o2 : O := blankSeparate l2
-        if ((rep n).flag)
-          then
-            o3 := message(" closed == true")
-          else 
-            o3 := message(" closed == false")
-        l := [o1,o2,o3]
-        bracket commaSeparate l
-
-@
-\section{domain SPLTREE SplittingTree}
-<<domain SPLTREE SplittingTree>>=
-)abbrev domain SPLTREE SplittingTree
-++ Author: Marc Moereno Maza
-++ Date Created: 07/05/1996
-++ Date Last Updated:  07/19/1996
-++ Basic Functions:
-++ Related Constructors:
-++ Also See: 
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++      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: 
-++    This domain exports a modest implementation of splitting 
-++    trees. Spliiting trees are needed when the 
-++    evaluation of some quantity under some hypothesis
-++    requires to split the hypothesis into sub-cases.
-++    For instance by adding some new hypothesis on one
-++    hand and its negation on another hand. The computations
-++    are terminated is a splitting tree \axiom{a} when
-++    \axiom{status(value(a))} is \axiom{true}. Thus,
-++    if for the splitting tree \axiom{a} the flag
-++    \axiom{status(value(a))} is \axiom{true}, then
-++    \axiom{status(value(d))} is \axiom{true} for any
-++    subtree \axiom{d} of \axiom{a}. This property
-++    of splitting trees is called the termination
-++    condition. If no vertex in a splitting tree \axiom{a}
-++    is equal to another, \axiom{a} is said to satisfy
-++    the no-duplicates condition. The splitting 
-++    tree \axiom{a} will satisfy this condition 
-++    if nodes are added to \axiom{a} by mean of 
-++    \axiom{splitNodeOf!} and if \axiom{construct}
-++    is only used to create the root of \axiom{a}
-++    with no children.
-
-SplittingTree(V,C) : Exports == Implementation where
-
-  V:Join(SetCategory,Aggregate)
-  C:Join(SetCategory,Aggregate)
-  B ==> Boolean
-  O ==> OutputForm
-  NNI ==> NonNegativeInteger
-  VT ==> Record(val:V, tower:C)
-  VTB ==> Record(val:V, tower:C, flag:B)
-  S ==> SplittingNode(V,C)
-  A ==> Record(root:S,subTrees:List(%))
-
-  Exports ==  RecursiveAggregate(S) with
-     shallowlyMutable
-     finiteAggregate
-     extractSplittingLeaf : % -> Union(%,"failed")
-       ++ \axiom{extractSplittingLeaf(a)} returns the left
-       ++ most leaf (as a tree) whose status is false
-       ++ if any, else "failed" is returned.
-     updateStatus! : % -> %
-       ++ \axiom{updateStatus!(a)} returns a where the status
-       ++ of the vertices are updated to satisfy 
-       ++ the "termination condition".
-     construct : S -> %
-       ++ \axiom{construct(s)} creates a splitting tree
-       ++ with value (i.e. root vertex) given by
-       ++ \axiom{s} and no children. Thus, if the
-       ++ status of \axiom{s} is false, \axiom{[s]}
-       ++ represents the starting point of the 
-       ++ evaluation \axiom{value(s)} under the 
-       ++ hypothesis \axiom{condition(s)}.
-     construct : (V,C, List %) -> %
-       ++ \axiom{construct(v,t,la)} creates a splitting tree
-       ++ with value (i.e. root vertex) given by
-       ++ \axiom{[v,t]$S} and with \axiom{la} as 
-       ++ children list.
-     construct : (V,C,List S) -> %
-       ++ \axiom{construct(v,t,ls)} creates a splitting tree
-       ++ with value (i.e. root vertex) given by
-       ++ \axiom{[v,t]$S} and with children list given by
-       ++ \axiom{[[s]$% for s in ls]}.
-     construct : (V,C,V,List C) -> %
-       ++ \axiom{construct(v1,t,v2,lt)} creates a splitting tree
-       ++ with value (i.e. root vertex) given by
-       ++ \axiom{[v,t]$S} and with children list given by
-       ++ \axiom{[[[v,t]$S]$% for s in ls]}.
-     conditions : % -> List C
-       ++ \axiom{conditions(a)} returns the list of the conditions
-       ++ of the leaves of a 
-     result : % -> List VT
-       ++ \axiom{result(a)} where \axiom{ls} is the leaves list of \axiom{a}
-       ++ returns \axiom{[[value(s),condition(s)]$VT for s in ls]}
-       ++ if the computations are terminated in \axiom{a} else
-       ++ an error is produced.
-     nodeOf? : (S,%) -> B
-       ++ \axiom{nodeOf?(s,a)} returns true iff some node of \axiom{a}
-       ++ is equal to \axiom{s}
-     subNodeOf? : (S,%,(C,C) -> B) -> B
-       ++ \axiom{subNodeOf?(s,a,sub?)} returns true iff for some node
-       ++ \axiom{n} in \axiom{a} we have \axiom{s = n} or
-       ++ \axiom{status(n)} and \axiom{subNode?(s,n,sub?)}.
-     remove : (S,%) -> %
-       ++ \axiom{remove(s,a)} returns the splitting tree obtained 
-       ++ from a by removing every sub-tree \axiom{b} such
-       ++ that \axiom{value(b)} and \axiom{s} have the same
-       ++ value, condition and status.
-     remove! : (S,%) -> %
-       ++ \axiom{remove!(s,a)} replaces a by remove(s,a)
-     splitNodeOf! : (%,%,List(S)) -> %
-       ++ \axiom{splitNodeOf!(l,a,ls)} returns \axiom{a} where the children
-       ++ list of \axiom{l} has been set to
-       ++ \axiom{[[s]$% for s in ls | not nodeOf?(s,a)]}.
-       ++ Thus, if \axiom{l} is not a node of \axiom{a}, this
-       ++ latter splitting tree is unchanged.
-     splitNodeOf! : (%,%,List(S),(C,C) -> B) -> %
-       ++ \axiom{splitNodeOf!(l,a,ls,sub?)} returns \axiom{a} where the children
-       ++ list of \axiom{l} has been set to
-       ++ \axiom{[[s]$% for s in ls | not subNodeOf?(s,a,sub?)]}.
-       ++ Thus, if \axiom{l} is not a node of \axiom{a}, this
-       ++ latter splitting tree is unchanged.
-
-
-  Implementation == add
-
-     Rep ==> A
-
-     rep(n:%):Rep == n pretend Rep
-     per(r:Rep):% == r pretend %
-
-     construct(s:S) == 
-        per [s,[]]$A
-     construct(v:V,t:C,la:List(%)) ==
-        per [[v,t]$S,la]$A
-     construct(v:V,t:C,ls:List(S)) ==
-        per [[v,t]$S,[[s]$% for s in ls]]$A
-     construct(v1:V,t:C,v2:V,lt:List(C)) ==
-        [v1,t,([v2,lt]$S)@(List S)]$%
-
-     empty?(a:%) == empty?((rep a).root) and empty?((rep a).subTrees)
-     empty() == [empty()$S]$%
-
-     remove(s:S,a:%) ==
-       empty? a => a
-       (s = value(a)) and (status(s) = status(value(a))) => empty()$%
-       la := children(a)
-       lb : List % := []
-       while (not empty? la) repeat
-          lb := cons(remove(s,first la), lb)
-          la := rest la
-       lb := reverse remove(empty?,lb)
-       [value(value(a)),condition(value(a)),lb]$%
-
-     remove!(s:S,a:%) ==
-       empty? a => a
-       (s = value(a)) and (status(s) = status(value(a))) =>
-         (rep a).root := empty()$S
-         (rep a).subTrees := []
-         a
-       la := children(a)
-       lb : List % := []
-       while (not empty? la) repeat
-          lb := cons(remove!(s,first la), lb)
-          la := rest la
-       lb := reverse remove(empty()$%,lb)
-       setchildren!(a,lb)
-
-     value(a:%) == 
-        (rep a).root
-     children(a:%) == 
-        (rep a).subTrees
-     leaf?(a:%) == 
-        empty? a => false
-        empty? (rep a).subTrees
-     setchildren!(a:%,la:List(%)) == 
-        (rep a).subTrees := la
-        a
-     setvalue!(a:%,s:S) ==
-        (rep a).root := s
-        s
-     cyclic?(a:%) == false
-     map(foo:(S -> S),a:%) ==
-       empty? a => a
-       b : % := [foo(value(a))]$%
-       leaf? a => b
-       setchildren!(b,[map(foo,c) for c in children(a)])
-     map!(foo:(S -> S),a:%) ==
-       empty? a => a
-       setvalue!(a,foo(value(a)))
-       leaf? a => a
-       setchildren!(a,[map!(foo,c) for c in children(a)])
-     copy(a:%) == 
-       map(copy,a)
-     eq?(a1:%,a2:%) ==
-       error"in eq? from SPLTREE : la vache qui rit est-elle folle?"
-     nodes(a:%) == 
-       empty? a => []
-       leaf? a => [a]
-       cons(a,concat([nodes(c) for c in children(a)]))
-     leaves(a:%) ==
-       empty? a => []
-       leaf? a => [value(a)]
-       concat([leaves(c) for c in children(a)])
-     members(a:%) ==
-       empty? a => []
-       leaf? a => [value(a)]
-       cons(value(a),concat([members(c) for c in children(a)]))
-     #(a:%) ==
-       empty? a => 0$NNI
-       leaf? a => 1$NNI
-       reduce("+",[#c for c in children(a)],1$NNI)$(List NNI)
-     a1:% = a2:% ==
-       empty? a1 => empty? a2
-       empty? a2 => false
-       leaf? a1 =>
-         not leaf? a2 => false
-         value(a1) =$S value(a2)
-       leaf? a2 => false
-       value(a1) ~=$S value(a2) => false
-       children(a1) = children(a2)
-     -- sample() == [sample()$S]$%
-     localCoerce(a:%,k:NNI):O ==
-       s : String
-       if k = 1 then  s := "* " else s := "-> "
-       for i in 2..k repeat s := concat("-+",s)$String
-       ro : O := left(hconcat(message(s)$O,value(a)::O)$O)$O
-       leaf? a => ro
-       lo : List O := [localCoerce(c,k+1) for c in children(a)]
-       lo := cons(ro,lo)
-       vconcat(lo)$O
-     coerce(a:%):O ==
-       empty? a => vconcat(message(" ")$O,message("* []")$O)
-       vconcat(message(" ")$O,localCoerce(a,1))
-       
-     extractSplittingLeaf(a:%) ==
-       empty? a => "failed"::Union(%,"failed")
-       status(value(a))$S => "failed"::Union(%,"failed")
-       la := children(a)
-       empty? la => a
-       while (not empty? la) repeat
-          esl := extractSplittingLeaf(first la)
-          (esl case %) => return(esl)
-          la := rest la
-       "failed"::Union(%,"failed")
-       
-     updateStatus!(a:%) ==
-       la := children(a)
-       (empty? la) or (status(value(a))$S) => a
-       done := true
-       while (not empty? la) and done repeat
-          done := done and status(value(updateStatus! first la))
-          la := rest la
-       setStatus!(value(a),done)$S
-       a
-     
-     result(a:%) ==
-       empty? a => []
-       not status(value(a))$S => 
-          error"in result from SLPTREE : mad cow!"
-       ls : List S := leaves(a)
-       [[value(s),condition(s)]$VT for s in ls]
-
-     conditions(a:%) ==
-       empty? a => []
-       ls : List S := leaves(a)
-       [condition(s) for s in ls]
-
-     nodeOf?(s:S,a:%) ==
-       empty? a => false
-       s =$S value(a) => true
-       la := children(a)
-       while (not empty? la) and (not nodeOf?(s,first la)) repeat
-          la := rest la
-       not empty? la
-
-     subNodeOf?(s:S,a:%,sub?:((C,C) -> B)) ==
-       empty? a => false
-       -- s =$S value(a) => true
-       status(value(a)$%)$S and subNode?(s,value(a),sub?)$S => true
-       la := children(a)
-       while (not empty? la) and (not subNodeOf?(s,first la,sub?)) repeat
-          la := rest la
-       not empty? la
-
-     splitNodeOf!(l:%,a:%,ls:List(S)) ==
-       ln := removeDuplicates ls
-       la : List % := []
-       while not empty? ln repeat
-          if not nodeOf?(first ln,a)
-            then
-              la := cons([first ln]$%, la)
-          ln := rest ln
-       la := reverse la
-       setchildren!(l,la)$%
-       if empty? la then (rep l).root := [empty()$V,empty()$C,true]$S
-       updateStatus!(a)
-
-     splitNodeOf!(l:%,a:%,ls:List(S),sub?:((C,C) -> B)) ==
-       ln := removeDuplicates ls
-       la : List % := []
-       while not empty? ln repeat
-          if not subNodeOf?(first ln,a,sub?)
-            then
-              la := cons([first ln]$%, la)
-          ln := rest ln
-       la := reverse la
-       setchildren!(l,la)$%
-       if empty? la then (rep l).root := [empty()$V,empty()$C,true]$S
-       updateStatus!(a)
-
-@
 \section{License}
 <<license>>=
 --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
@@ -676,8 +216,6 @@ SplittingTree(V,C) : Exports == Implementation where
 
 <<package IPRNTPK InternalPrintPackage>>
 <<package TBCMPPK TabulatedComputationPackage>>
-<<domain SPLNODE SplittingNode>>
-<<domain SPLTREE SplittingTree>>
 @
 \eject
 \begin{thebibliography}{99}
diff --git a/src/algebra/newpoint.spad.pamphlet b/src/algebra/newpoint.spad.pamphlet
index 9694c39..ea9e1ff 100644
--- a/src/algebra/newpoint.spad.pamphlet
+++ b/src/algebra/newpoint.spad.pamphlet
@@ -9,540 +9,6 @@
 \eject
 \tableofcontents
 \eject
-\section{domain POINT Point}
-<<domain POINT Point>>=
-)abbrev domain POINT Point
-++ Description:
-++ This domain implements points in coordinate space
- 
-Point(R:Ring) : Exports == Implementation where
-  -- Domains for points, subspaces and properties of components in
-  -- a subspace
- 
-  Exports ==> PointCategory(R)
- 
-  Implementation ==> Vector (R) add
-    PI   ==> PositiveInteger
-
-    point(l:List R):% ==
-      pt := new(#l,R)
-      for x in l for i in minIndex(pt).. repeat
-        pt.i := x
-      pt
-    dimension p == (# p)::PI  -- Vector returns NonNegativeInteger...?
-    convert(l:List R):% == point(l)
-    cross(p0, p1) ==
-      #p0 ^=3 or #p1^=3 => error "Arguments to cross must be three dimensional"      
-      point [p0.2 * p1.3 - p1.2 * p0.3, _
-             p1.1 * p0.3 - p0.1 * p1.3, _
-             p0.1 * p1.2 - p1.1 * p0.2]
-    extend(p,l) == concat(p,point l)
-
-@
-\section{domain COMPPROP SubSpaceComponentProperty}
-<<domain COMPPROP SubSpaceComponentProperty>>=
-)abbrev domain COMPPROP SubSpaceComponentProperty
-++ Description:
-++ This domain implements some global properties of subspaces.
- 
-SubSpaceComponentProperty() : Exports == Implementation where
- 
-  O ==> OutputForm
-  I    ==> Integer
-  PI   ==> PositiveInteger
-  NNI  ==> NonNegativeInteger
-  L    ==> List
-  B    ==> Boolean
- 
-  Exports ==> SetCategory with
-    new     : () -> %
-	++ new() \undocumented
-    closed? : % -> B
-	++ closed?(x) \undocumented
-    solid?  : % -> B
-	++ solid?(x) \undocumented
-    close   : (%,B) -> B
-	++ close(x,b) \undocumented
-    solid   : (%,B) -> B
-	++ solid(x,b) \undocumented
-    copy    : % -> %
-	++ copy(x) \undocumented
- 
-  Implementation ==> add
-    Rep := Record(closed:B, solid:B)
-    closed? p == p.closed
-    solid? p == p.solid
-    close(p,b) == p.closed := b
-    solid(p,b) == p.solid := b
-    new() == [false,false]
-    copy p ==
-      annuderOne := new()
-      close(annuderOne,closed? p)
-      solid(annuderOne,solid? p)
-      annuderOne
-    coerce p ==
-      hconcat(["Component is "::O,
-              (closed? p => ""::O; "not "::O),"closed, "::O, _
-              (solid? p => ""::O; "not "::O),"solid"::O ])
-
-@
-\section{domain SUBSPACE SubSpace}
-<<domain SUBSPACE SubSpace>>=
-)abbrev domain SUBSPACE SubSpace
-++ Description:
-++ This domain \undocumented
-SubSpace(n:PI,R:Ring) : Exports == Implementation where
-  -- n is the dimension of the subSpace
-  -- The SubSpace domain is implemented as a tree. The root of the tree
-  -- is the only node in which the field dataList - which points to a
-  -- list of points over the ring, R - is defined. The children of the
-  -- root are the top level components of the SubSpace (in 2D, these
-  -- would be separate curves; in 3D, these would be separate surfaces).
-  -- The pt field is only defined in the leaves.
-  -- By way of example, consider a three dimensional subspace with
-  -- two components - a three by three grid and a sphere. The internal
-  -- representation of this subspace is a tree with a depth of three.
-  -- The root holds a list of all the points used in the subspace (so,
-  -- if the grid and the sphere share points, the shared points would not
-  -- be represented redundantly but would be referenced by index).
-  -- The root, in this case, has two children - the first points to the
-  -- grid component and the second to the sphere component. The grid child
-  -- has four children of its own - a 3x3 grid has 4 endpoints - and each
-  -- of these point to a list of four points. To see it another way, the 
-  -- grid (child of the root) holds a list of line components which, when
-  -- placed one above the next, forms a grid. Each of these line components
-  -- is a list of points.
-  -- Points could be explicitly added to subspaces at any level. A path
-  -- could be given as an argument to the addPoint() function. It is a list
-  -- of NonNegativeIntegers and refers, in order, to the n-th child of the
-  -- current node. For example,
-  --                     addPoint(s,[2,3],p)
-  -- would add the point p to the subspace s by going to the second child of
-  -- the root and then the third child of that node. If the path does extend
-  -- to the full depth of the tree, nodes are automatically added so that 
-  -- the tree is of constant depth down any path. By not specifying the full
-  -- path, new components could be added - e.g. for s from SubSpace(3,Float)
-  --                     addPoint(s,[],p)
-  -- would create a new child to the root (a new component in N-space) and
-  -- extend a path to a leaf of depth 3 that points to the data held in p.
-  -- The subspace s would now have a new component which has one child
-  -- which, in turn, has one child (the leaf). The new component is then a 
-  -- point.
- 
-  I    ==> Integer
-  PI   ==> PositiveInteger
-  NNI  ==> NonNegativeInteger
-  L    ==> List
-  B    ==> Boolean
-  POINT ==> Point(R)
-  PROP ==> SubSpaceComponentProperty()
-  S ==> String
-  O ==> OutputForm
-  empty ==> nil  -- macro to ease conversion to new aggcat.spad
- 
-  Exports ==> SetCategory with
-    leaf?          : % -> B
-	++ leaf?(x) \undocumented
-    root?          : % -> B
-	++ root?(x) \undocumented
-    internal?      : % -> B
-	++ internal?(x) \undocumented
-    new            : () -> %
-	++ new() \undocumented
-    subspace       : () -> %
-	++ subspace() \undocumented
-    birth          : % -> %       -- returns a pointer to the baby
-	++ birth(x) \undocumented
-    child          : (%,NNI) -> %
-	++ child(x,n) \undocumented
-    children       : % -> List %
-	++ children(x) \undocumented
-    numberOfChildren: % -> NNI
-	++ numberOfChildren(x) \undocumented
-    shallowCopy    : % -> %
-	++ shallowCopy(x) \undocumented
-    deepCopy       : % -> %
-	++ deepCopy(x) \undocumented
-    merge          : (%,%) -> %
-      ++ merge(s1,s2) the subspaces s1 and s2 into a single subspace.
-    merge          : List % -> %
-      ++ merge(ls) a list of subspaces, ls, into one subspace.
-    separate       : % -> List %
-      ++ separate(s) makes each of the components of the \spadtype{SubSpace},
-      ++ s, into a list of separate and distinct subspaces and returns
-      ++ the list.
-    addPoint       : (%,List NNI,POINT) -> %
-      ++ addPoint(s,li,p) adds the 4 dimensional point, p, to the 3 
-      ++ dimensional subspace, s. The list of non negative integers, li, 
-      ++ dictates the path to follow, or, to look at it another way, 
-      ++ points to the component in which the point is to be added.  It's 
-      ++ length should range from 0 to \spad{n - 1} where n is the dimension 
-      ++ of the subspace. If the length is \spad{n - 1}, then a specific 
-      ++ lowest level component is being referenced.  If it is less than 
-      ++ \spad{n - 1}, then some higher level component (0 indicates top 
-      ++ level component) is being referenced and a component of that level 
-      ++ with the desired point is created.  The subspace s is returned
-      ++ with the additional point.
-    addPoint2      : (%,POINT) -> %
-      ++ addPoint2(s,p) adds the 4 dimensional point, p, to the 3 
-      ++ dimensional subspace, s. 
-      ++ The subspace s is returned with the additional point.
-    addPointLast   : (%,%,POINT, NNI) -> %
-      ++ addPointLast(s,s2,li,p) adds the 4 dimensional point, p, to the 3 
-      ++ dimensional subspace, s. s2 point to the end of the subspace
-      ++ s. n is the path in the s2 component.
-      ++ The subspace s is returned with the additional point.
-    modifyPoint    : (%,List NNI,POINT) -> %
-      ++ modifyPoint(s,li,p) replaces an existing point in the 3 dimensional
-      ++ subspace, s, with the 4 dimensional point, p.  The list of non 
-      ++ negative integers, li, dictates the path to follow, or, to look at 
-      ++ it another way, points to the component in which the existing point 
-      ++ is to be modified.  An error message occurs if s is empty, otherwise
-      ++ the subspace s is returned with the point modification.
-    addPoint       : (%,List NNI,NNI) -> %
-      ++ addPoint(s,li,i) adds the 4 dimensional point indicated by the
-      ++ index location, i, to the 3 dimensional subspace, s. The list of 
-      ++ non negative integers, li, dictates the path to follow, or, to 
-      ++ look at it another way, points to the component in which the point 
-      ++ is to be added.  It's length should range from 0 to \spad{n - 1} 
-      ++ where n is the dimension of the subspace. If the length is 
-      ++ \spad{n - 1}, then a specific lowest level component is being 
-      ++ referenced.  If it is less than \spad{n - 1}, then some higher 
-      ++ level component (0 indicates top level component) is being 
-      ++ referenced and a component of that level with the desired point 
-      ++ is created.  The subspace s is returned with the additional point.
-    modifyPoint    : (%,List NNI,NNI) -> %
-      ++ modifyPoint(s,li,i) replaces an existing point in the 3 dimensional
-      ++ subspace, s, with the 4 dimensional point indicated by the index 
-      ++ location, i.  The list of non negative integers, li, dictates 
-      ++ the path to follow, or, to look at it another way, points to the 
-      ++ component in which the existing point is to be modified.  An error
-      ++ message occurs if s is empty, otherwise the subspace s is returned
-      ++ with the point modification.
-    addPoint       : (%,POINT) -> NNI
-      ++ addPoint(s,p) adds the point, p, to the 3 dimensional subspace, s,
-      ++ and returns the new total number of points in s.
-    modifyPoint    : (%,NNI,POINT) -> %
-      ++ modifyPoint(s,ind,p) modifies the point referenced by the index
-      ++ location, ind, by replacing it with the point, p in the 3 dimensional
-      ++ subspace, s.  An error message occurs if s is empty, otherwise the
-      ++ subspace s is returned with the point modification.
- 
-    closeComponent : (%,List NNI,B)     -> %
-      ++ closeComponent(s,li,b) sets the property of the component in the
-      ++ 3 dimensional subspace, s, to be closed if b is true, or open if 
-      ++ b is false.  The list of non negative integers, li, dictates the 
-      ++ path to follow, or, to look at it another way, points to the 
-      ++ component whose closed property is to be set.  The subspace, s, 
-      ++ is returned with the component property modification.
-    defineProperty : (%,List NNI,PROP)  -> %
-      ++ defineProperty(s,li,p) defines the component property in the
-      ++ 3 dimensional subspace, s, to be that of p, where p is of the
-      ++ domain \spadtype{SubSpaceComponentProperty}.  The list of non 
-      ++ negative integers, li, dictates the path to follow, or, to look 
-      ++ at it another way, points to the component whose property is 
-      ++ being defined.  The subspace, s, is returned with the component 
-      ++ property definition.
-    traverse       : (%,List NNI) -> %
-      ++ traverse(s,li) follows the branch list of the 3 dimensional 
-      ++ subspace, s, along the path dictated by the list of non negative
-      ++ integers, li, which points to the component which has been
-      ++ traversed to.  The subspace, s, is returned, where s is now
-      ++ the subspace pointed to by li.
-    extractPoint    : %  -> POINT
-      ++ extractPoint(s) returns the point which is given by the current 
-      ++ index location into the point data field of the 3 dimensional 
-      ++ subspace s.
-    extractIndex    : % -> NNI
-      ++ extractIndex(s) returns a non negative integer which is the current 
-      ++ index of the 3 dimensional subspace s.
-    extractClosed   : %  -> B
-      ++ extractClosed(s) returns the \spadtype{Boolean} value of the closed 
-      ++ property for the indicated 3 dimensional subspace s.  If the 
-      ++ property is closed, \spad{True} is returned, otherwise \spad{False}
-      ++ is returned.
-    extractProperty : %  -> PROP
-      ++ extractProperty(s) returns the property of domain
-      ++ \spadtype{SubSpaceComponentProperty} of the indicated 3 dimensional
-      ++ subspace s.
-    level           : % -> NNI
-      ++ level(s) returns a non negative integer which is the current 
-      ++ level field of the indicated 3 dimensional subspace s.
-    parent          : % -> %
-      ++ parent(s) returns the subspace which is the parent of the indicated
-      ++ 3 dimensional subspace s.  If s is the top level subspace an error
-      ++ message is returned.
-    pointData       : % -> L POINT
-      ++ pointData(s) returns the list of points from the point data field
-      ++ of the 3 dimensional subspace s.
- 
-  Implementation ==> add
-    import String()
-
-    Rep := Record(pt:POINT, index:NNI, property:PROP, _
-                   childrenField:List %, _
-                   lastChild: List %, _ 
-                   levelField:NNI, _
-                   pointDataField:L POINT, _
-                   lastPoint: L POINT, _
-                   noPoints: NNI, _
-                   noChildren: NNI, _
-                   parentField:List %) -- needn't be list but...base case?
-
-    TELLWATT : String := "Non-null list: Please inform Stephen Watt"
- 
-    leaf? space ==  empty? children space
-    root? space == (space.levelField = 0$NNI)
-    internal? space == ^(root? space and leaf? space)
- 
-    new() ==
-      [point(empty())$POINT,0,new()$PROP,empty(),empty(),0,_
-                                     empty(),empty(),0,0,empty()]
-    subspace() == new()
- 
-    birth momma ==
-      baby := new()
-      baby.levelField := momma.levelField+1
-      baby.parentField := [momma]
-      if not empty?(lastKid := momma.lastChild) then
-        not empty? rest lastKid => error TELLWATT
-      if empty? lastKid
-        then
-          momma.childrenField := [baby]
-          momma.lastChild := momma.childrenField
-          momma.noChildren := 1
-        else
-          setrest_!(lastKid,[baby])
-          momma.lastChild := rest lastKid
-          momma.noChildren := momma.noChildren + 1
-      baby
- 
-    child(space,num) ==
-      space.childrenField.num
-
-    children space == space.childrenField
-    numberOfChildren space == space.noChildren
- 
-    shallowCopy space ==
-      node := new()
-      node.pt         := space.pt
-      node.index      := space.index
-      node.property   := copy(space.property)
-      node.levelField := space.levelField
-      node.parentField := nil()
-      if root? space then
-        node.pointDataField := copy(space.pointDataField)
-        node.lastPoint := tail(node.pointDataField)
-        node.noPoints := space.noPoints
-      node
-
-    deepCopy space ==
-      node := shallowCopy(space)
-      leaf? space => node
-      for c in children space repeat
-        cc := deepCopy c
-        cc.parentField := [node]
-        node.childrenField := cons(cc,node.childrenField)
-      node.childrenField := reverse_!(node.childrenField)
-      node.lastChild := tail node.childrenField
-      node
-
-    merge(s1,s2) ==
-       ------------------ need to worry about reindexing s2 & parentField
-      n1 : Rep := deepCopy s1
-      n2 : Rep := deepCopy s2
-      n1.childrenField := append(children n1,children n2)
-      n1
-
-    merge listOfSpaces ==
-       ------------------ need to worry about reindexing & parentField
-      empty? listOfSpaces => error "empty list passed as argument to merge"
-           -- notice that the properties of the first subspace on the
-           -- list are the ones that are inherited...hmmmm...
-      space := deepCopy first listOfSpaces
-      for s in rest listOfSpaces repeat
-           -- because of the initial deepCopy, above, everything is
-           -- deepCopied to be consistent...more hmmm...
-        space.childrenField := append(space.childrenField,[deepCopy c for c in s.childrenField])
-      space
-
-    separate space ==
-       ------------------ need to worry about reindexing & parentField
-      spaceList := empty()
-      for s in space.childrenField repeat
-        spc:=shallowCopy space
-        spc.childrenField:=[deepCopy s]
-        spaceList := cons(spc,spaceList)
-      spaceList
- 
-    addPoint(space:%,path:List NNI,point:POINT) ==
-      if not empty?(lastPt := space.lastPoint) then
-        not empty? rest lastPt => error TELLWATT
-      if empty? lastPt
-        then
-          space.pointDataField := [point]
-          space.lastPoint := space.pointDataField
-        else
-          setrest_!(lastPt,[point])
-          space.lastPoint := rest lastPt
-      space.noPoints := space.noPoints + 1
-      which := space.noPoints
-      node := space
-      depth : NNI := 0
-      for i in path repeat
-        node := child(node,i)
-        depth := depth + 1
-      for more in depth..(n-1) repeat
-        node := birth node
-      node.pt := point      -- will be obsolete field
-      node.index := which
-      space
-
-    addPoint2(space:%,point:POINT) ==
-      if not empty?(lastPt := space.lastPoint) then
-        not empty? rest lastPt => error TELLWATT
-      if empty? lastPt
-        then
-          space.pointDataField := [point]
-          space.lastPoint := space.pointDataField
-        else
-          setrest_!(lastPt,[point])
-          space.lastPoint := rest lastPt
-      space.noPoints := space.noPoints + 1
-      which := space.noPoints
-      node := space
-      depth : NNI := 0
-      node := birth node
-      first := node
-      for more in 1..n-1 repeat
-        node := birth node
-      node.pt := point      -- will be obsolete field
-      node.index := which
-      first
-
-    addPointLast(space:%,node:%, point:POINT, depth:NNI) ==
-      if not empty?(lastPt := space.lastPoint) then
-        not empty? rest lastPt => error TELLWATT
-      if empty? lastPt
-        then
-          space.pointDataField := [point]
-          space.lastPoint := space.pointDataField
-        else
-          setrest_!(lastPt,[point])
-          space.lastPoint := rest lastPt
-      space.noPoints := space.noPoints + 1
-      which := space.noPoints
-      if depth = 2 then node := child(node, 2)
-      for more in depth..(n-1) repeat
-        node := birth node
-      node.pt := point      -- will be obsolete field
-      node.index := which
-      node -- space
-
-    addPoint(space:%,path:List NNI,which:NNI) ==
-      node := space
-      depth : NNI := 0
-      for i in path repeat
-        node := child(node,i)
-        depth := depth + 1
-      for more in depth..(n-1) repeat
-        node := birth node
-      node.pt := space.pointDataField.which   -- will be obsolete field
-      node.index := which
-      space
-
-    addPoint(space:%,point:POINT) ==
-      root? space =>
-        if not empty?(lastPt := space.lastPoint) then
-          not empty? rest lastPt => error TELLWATT
-        if empty? lastPt
-          then
-            space.pointDataField := [point]
-            space.lastPoint := space.pointDataField
-          else
-            setrest_!(lastPt,[point])
-            space.lastPoint := rest lastPt
-        space.noPoints := space.noPoints + 1
-      error "You need to pass a top level SubSpace (level should be zero)"
- 
-    modifyPoint(space:%,path:List NNI,point:POINT) ==
-      if not empty?(lastPt := space.lastPoint) then
-        not empty? rest lastPt => error TELLWATT
-      if empty? lastPt
-        then
-          space.pointDataField := [point]
-          space.lastPoint := space.pointDataField
-        else
-          setrest_!(lastPt,[point])
-          space.lastPoint := rest lastPt
-      space.noPoints := space.noPoints + 1
-      which := space.noPoints
-      node := space
-      for i in path repeat
-        node := child(node,i)
-      node.pt := point       ---------- will be obsolete field
-      node.index := which
-      space
-
-    modifyPoint(space:%,path:List NNI,which:NNI) ==
-      node := space
-      for i in path repeat
-        node := child(node,i)
-      node.pt := space.pointDataField.which       ---------- will be obsolete field
-      node.index := which
-      space
-
-    modifyPoint(space:%,which:NNI,point:POINT) ==
-      root? space =>
-        space.pointDataField.which := point
-        space
-      error "You need to pass a top level SubSpace (level should be zero)"
- 
-    closeComponent(space,path,val) ==
-      node := space
-      for i in path repeat
-        node := child(node,i)
-      close(node.property,val)
-      space
-
-    defineProperty(space,path,prop) ==
-      node := space
-      for i in path repeat
-        node := child(node,i)
-      node.property := prop
-      space
- 
-    traverse(space,path) ==
-      for i in path repeat space := child(space,i)
-      space
-
-    extractPoint space ==
-      node := space
-      while ^root? node repeat node := parent node
-      (node.pointDataField).(space.index)
-    extractIndex space == space.index
-    extractClosed space == closed? space.property
-    extractProperty space == space.property
- 
-    parent space ==
-      empty? space.parentField => error "This is a top level SubSpace - it does not have a parent"
-      first space.parentField
-    pointData space == space.pointDataField
-    level space == space.levelField
-    s1 = s2 ==
-        ------------ extra checks for list of point data
-      (leaf? s1 and leaf? s2) =>
-        (s1.pt = s2.pt) and (s1.property = s2.property) and (s1.levelField = s2.levelField)
-      -- note that the ordering of children is important
-      #s1.childrenField ^= #s2.childrenField => false
-      and/[c1 = c2 for c1 in s1.childrenField for c2 in s2.childrenField]
-       and (s1.property = s2.property) and (s1.levelField = s2.levelField)
-    coerce(space:%):O ==
-      hconcat([n::O,"-Space with depth of "::O,                     _
-              (n - space.levelField)::O," and "::O,(s:=(#space.childrenField))::O,  _
-              (s=1 => " component"::O;" components"::O)])
-
-@
 \section{package PTPACK PointPackage}
 <<package PTPACK PointPackage>>=
 )abbrev package PTPACK PointPackage
@@ -685,9 +151,6 @@ PointFunctions2(R1:Ring,R2:Ring):Exports == Implementation where
 <<*>>=
 <<license>>
 
-<<domain POINT Point>>
-<<domain COMPPROP SubSpaceComponentProperty>>
-<<domain SUBSPACE SubSpace>>
 <<package PTPACK PointPackage>>
 <<package PTFUNC2 PointFunctions2>>
 @
diff --git a/src/algebra/newpoly.spad.pamphlet b/src/algebra/newpoly.spad.pamphlet
index 220b8f0..bfe4d01 100644
--- a/src/algebra/newpoly.spad.pamphlet
+++ b/src/algebra/newpoly.spad.pamphlet
@@ -9,265 +9,6 @@
 \eject
 \tableofcontents
 \eject
-Based on the {\bf PseudoRemainderSequence} package, the domain
-constructor {\bf NewSparseUnivariatePolynomial} extends the
-constructur {\bf SparseUnivariatePolynomial}. 
-\section{domain NSUP NewSparseUnivariatePolynomial}
-<<domain NSUP NewSparseUnivariatePolynomial>>=
-)abbrev domain NSUP NewSparseUnivariatePolynomial
-++ Author: Marc Moreno Maza
-++ Date Created: 23/07/98
-++ Date Last Updated: 14/12/98
-++ Basic Operations: 
-++ Related Domains:
-++ Also See:
-++ AMS Classifications:
-++ Keywords: 
-++ Examples:
-++ References: 
-++ Description: A post-facto extension for \axiomType{SUP} in order
-++ to speed up operations related to pseudo-division and gcd for
-++ both \axiomType{SUP} and, consequently, \axiomType{NSMP}.
-
-NewSparseUnivariatePolynomial(R): Exports == Implementation where
-
-  R:Ring
-  NNI ==> NonNegativeInteger
-  SUPR ==> SparseUnivariatePolynomial R
-
-  Exports == Join(UnivariatePolynomialCategory(R), 
-   CoercibleTo(SUPR),RetractableTo(SUPR)) with
-     fmecg : (%,NNI,R,%) -> %
-        ++ \axiom{fmecg(p1,e,r,p2)} returns \axiom{p1 - r * X**e * p2}
-        ++ where \axiom{X} is \axiom{monomial(1,1)}
-     monicModulo : ($, $) -> $ 
-        ++ \axiom{monicModulo(a,b)} returns \axiom{r} such that \axiom{r} is 
-        ++ reduced w.r.t. \axiom{b} and \axiom{b} divides \axiom{a -r}
-        ++ where \axiom{b} is monic.
-     lazyResidueClass: ($,$) -> Record(polnum:$, polden:R, power:NNI)
-        ++ \axiom{lazyResidueClass(a,b)} returns \axiom{[r,c,n]} such that 
-        ++ \axiom{r} is reduced w.r.t. \axiom{b} and \axiom{b} divides 
-        ++ \axiom{c^n * a - r} where \axiom{c} is \axiom{leadingCoefficient(b)} 
-        ++ and \axiom{n} is as small as possible with the previous properties.
-     lazyPseudoRemainder: ($,$) -> $
-        ++ \axiom{lazyPseudoRemainder(a,b)} returns \axiom{r} if \axiom{lazyResidueClass(a,b)}
-        ++ returns \axiom{[r,c,n]}. This lazy pseudo-remainder is computed by 
-        ++ means of the \axiomOpFrom{fmecg}{NewSparseUnivariatePolynomial} operation.
-     lazyPseudoDivide: ($,$) -> Record(coef:R, gap:NNI, quotient:$, remainder: $)
-        ++ \axiom{lazyPseudoDivide(a,b)} returns \axiom{[c,g,q,r]} such that 
-        ++ \axiom{c^n * a = q*b +r} and \axiom{lazyResidueClass(a,b)} returns \axiom{[r,c,n]}
-        ++ where \axiom{n + g = max(0, degree(b) - degree(a) + 1)}.
-     lazyPseudoQuotient: ($,$) -> $
-        ++ \axiom{lazyPseudoQuotient(a,b)} returns \axiom{q} if \axiom{lazyPseudoDivide(a,b)}
-        ++ returns \axiom{[c,g,q,r]} 
-     if R has IntegralDomain
-     then 
-       subResultantsChain: ($, $) -> List $
-         ++ \axiom{subResultantsChain(a,b)} returns the list of the non-zero
-         ++ sub-resultants of \axiom{a} and \axiom{b} sorted by increasing 
-         ++ degree.
-       lastSubResultant: ($, $) -> $
-         ++ \axiom{lastSubResultant(a,b)} returns \axiom{resultant(a,b)}
-         ++ if \axiom{a} and \axiom{b} has no non-trivial gcd in \axiom{R^(-1) P}
-         ++ otherwise the non-zero sub-resultant with smallest index.
-       extendedSubResultantGcd: ($, $) -> Record(gcd: $, coef1: $, coef2: $)
-         ++ \axiom{extendedSubResultantGcd(a,b)} returns \axiom{[g,ca, cb]} such
-         ++ that \axiom{g} is a gcd of \axiom{a} and \axiom{b} in \axiom{R^(-1) P}
-         ++ and \axiom{g = ca * a + cb * b}
-       halfExtendedSubResultantGcd1: ($, $) -> Record(gcd: $, coef1: $)
-         ++ \axiom{halfExtendedSubResultantGcd1(a,b)} returns \axiom{[g,ca]} such that
-         ++ \axiom{extendedSubResultantGcd(a,b)} returns \axiom{[g,ca, cb]}
-       halfExtendedSubResultantGcd2: ($, $) -> Record(gcd: $, coef2: $)
-         ++ \axiom{halfExtendedSubResultantGcd2(a,b)} returns \axiom{[g,cb]} such that
-         ++ \axiom{extendedSubResultantGcd(a,b)} returns \axiom{[g,ca, cb]}
-       extendedResultant: ($, $) -> Record(resultant: R, coef1: $, coef2: $)
-         ++ \axiom{extendedResultant(a,b)} returns  \axiom{[r,ca,cb]} such that 
-         ++ \axiom{r} is the resultant of \axiom{a} and \axiom{b} and
-         ++ \axiom{r = ca * a + cb * b}
-       halfExtendedResultant1: ($, $) -> Record(resultant: R, coef1: $)
-         ++ \axiom{halfExtendedResultant1(a,b)} returns \axiom{[r,ca]} such that 
-         ++ \axiom{extendedResultant(a,b)}  returns \axiom{[r,ca, cb]} 
-       halfExtendedResultant2: ($, $) -> Record(resultant: R, coef2: $)
-         ++ \axiom{halfExtendedResultant2(a,b)} returns \axiom{[r,ca]} such that 
-         ++ \axiom{extendedResultant(a,b)} returns \axiom{[r,ca, cb]} 
-
-  Implementation == SparseUnivariatePolynomial(R) add
-   
-     Term == Record(k:NonNegativeInteger,c:R)
-     Rep ==> List Term
-
-     rep(s:$):Rep == s pretend Rep
-     per(l:Rep):$ == l pretend $
-
-     coerce (p:$):SUPR == 
-       p pretend SUPR
-
-     coerce (p:SUPR):$ == 
-       p pretend $
-
-     retractIfCan (p:$) : Union(SUPR,"failed") == 
-       (p pretend SUPR)::Union(SUPR,"failed")
-
-     monicModulo(x,y) ==
-		zero? y => 
-		   error "in monicModulo$NSUP: division by 0"
-		ground? y =>
-		   error "in monicModulo$NSUP: ground? #2"
-                yy := rep y
---                not one? (yy.first.c) => 
-                not ((yy.first.c) = 1) => 
-		   error "in monicModulo$NSUP: not monic #2"
-                xx := rep x; empty? xx => x
-                e := yy.first.k; y := per(yy.rest)                
-                -- while (not empty? xx) repeat
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  xx:= rep fmecg(per rest(xx), u, xx.first.c, y)
-                  if empty? xx then break
-                per xx
-
-     lazyResidueClass(x,y) ==
-		zero? y => 
-		   error "in lazyResidueClass$NSUP: division by 0"
-		ground? y =>
-		   error "in lazyResidueClass$NSUP: ground? #2"
-                yy := rep y; co := yy.first.c; xx: Rep := rep x
-                empty? xx => [x, co, 0]
-                pow: NNI := 0; e := yy.first.k; y := per(yy.rest); 
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  xx:= rep fmecg(co * per rest(xx), u, xx.first.c, y)
-                  pow := pow + 1
-                  if empty? xx then break
-                [per xx, co, pow]
-
-     lazyPseudoRemainder(x,y) ==
-		zero? y => 
-		   error "in lazyPseudoRemainder$NSUP: division by 0"
-		ground? y =>
-		   error "in lazyPseudoRemainder$NSUP: ground? #2"
-		ground? x => x
-                yy := rep y; co := yy.first.c
---                one? co => monicModulo(x,y)
-                (co = 1) => monicModulo(x,y)
-                (co = -1) => - monicModulo(-x,-y)
-                xx:= rep x; e := yy.first.k; y := per(yy.rest)
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  xx:= rep fmecg(co * per rest(xx), u, xx.first.c, y)
-                  if empty? xx then break
-                per xx
-
-     lazyPseudoDivide(x,y) ==
-		zero? y => 
-		   error "in lazyPseudoDivide$NSUP: division by 0"
-		ground? y =>
-		   error "in lazyPseudoDivide$NSUP: ground? #2"
-                yy := rep y; e := yy.first.k; 
-                xx: Rep := rep x; co := yy.first.c
-		(empty? xx) or (xx.first.k < e) => [co,0,0,x]
-                pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1
-                qq: Rep := []; y := per(yy.rest)
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
-                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
-                  pow := subtractIfCan(pow,1)::NNI
-                  if empty? xx then break
-                [co, pow, per reverse qq, per xx]
-
-     lazyPseudoQuotient(x,y) ==
-		zero? y => 
-		   error "in lazyPseudoQuotient$NSUP: division by 0"
-		ground? y =>
-		   error "in lazyPseudoQuotient$NSUP: ground? #2"
-                yy := rep y; e := yy.first.k; xx: Rep := rep x
-		(empty? xx) or (xx.first.k < e) => 0
-                qq: Rep := []; co := yy.first.c; y := per(yy.rest)
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
-                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
-                  if empty? xx then break
-                per reverse qq
-
-     if R has IntegralDomain
-     then 
-       pack ==> PseudoRemainderSequence(R, %)
-
-       subResultantGcd(p1,p2) == subResultantGcd(p1,p2)$pack
-
-       subResultantsChain(p1,p2) == chainSubResultants(p1,p2)$pack
-
-       lastSubResultant(p1,p2) == lastSubResultant(p1,p2)$pack
-
-       resultant(p1,p2) == resultant(p1,p2)$pack
-
-       extendedResultant(p1,p2) == 
-          re: Record(coef1: $, coef2: $, resultant: R) := resultantEuclidean(p1,p2)$pack
-          [re.resultant, re.coef1, re.coef2]
-
-       halfExtendedResultant1(p1:$, p2: $): Record(resultant: R, coef1: $) ==
-          re: Record(coef1: $, resultant: R) := semiResultantEuclidean1(p1, p2)$pack
-          [re.resultant, re.coef1]
-
-       halfExtendedResultant2(p1:$, p2: $): Record(resultant: R, coef2: $) ==
-          re: Record(coef2: $, resultant: R) := semiResultantEuclidean2(p1, p2)$pack
-          [re.resultant, re.coef2]
-
-       extendedSubResultantGcd(p1,p2) == 
-          re: Record(coef1: $, coef2: $, gcd: $) := subResultantGcdEuclidean(p1,p2)$pack
-          [re.gcd, re.coef1, re.coef2]
-
-       halfExtendedSubResultantGcd1(p1:$, p2: $): Record(gcd: $, coef1: $) ==
-          re: Record(coef1: $, gcd: $) := semiSubResultantGcdEuclidean1(p1, p2)$pack
-          [re.gcd, re.coef1]
-
-       halfExtendedSubResultantGcd2(p1:$, p2: $): Record(gcd: $, coef2: $) ==
-          re: Record(coef2: $, gcd: $) := semiSubResultantGcdEuclidean2(p1, p2)$pack
-          [re.gcd, re.coef2]
-
-       pseudoDivide(x,y) ==
-		zero? y => 
-		   error "in pseudoDivide$NSUP: division by 0"
-		ground? y =>
-		   error "in pseudoDivide$NSUP: ground? #2"
-                yy := rep y; e := yy.first.k
-                xx: Rep := rep x; co := yy.first.c
-		(empty? xx) or (xx.first.k < e) => [co,0,x]
-                pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1
-                qq: Rep := []; y := per(yy.rest)
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
-                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
-                  pow := subtractIfCan(pow,1)::NNI
-                  if empty? xx then break
-                zero? pow => [co, per reverse qq, per xx]
-                default: R := co ** pow
-                q := default * (per reverse qq)
-                x := default * (per xx)
-                [co, q, x]
-
-       pseudoQuotient(x,y) ==
-		zero? y => 
-		   error "in pseudoDivide$NSUP: division by 0"
-		ground? y =>
-		   error "in pseudoDivide$NSUP: ground? #2"
-                yy := rep y; e := yy.first.k; xx: Rep := rep x
-		(empty? xx) or (xx.first.k < e) => 0
-                pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1
-                qq: Rep := []; co := yy.first.c; y := per(yy.rest)
-                repeat
-                  if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break
-                  qq := cons([u::NNI, xx.first.c]$Term, rep (co * per qq))
-                  xx := rep fmecg(co * per rest(xx), u, xx.first.c, y)
-                  pow := subtractIfCan(pow,1)::NNI
-                  if empty? xx then break
-                zero? pow => per reverse qq
-                (co ** pow) * (per reverse qq)
-
-@
 \section{package NSUP2 NewSparseUnivariatePolynomialFunctions2}
 <<package NSUP2 NewSparseUnivariatePolynomialFunctions2>>=
 )abbrev package NSUP2 NewSparseUnivariatePolynomialFunctions2
@@ -297,411 +38,6 @@ NewSparseUnivariatePolynomialFunctions2(R:Ring, S:Ring): with
            NewSparseUnivariatePolynomial R, S, NewSparseUnivariatePolynomial S)
 
 @
-Based on the {\bf PseudoRemainderSequence} package, the domain
-constructor {\bf NewSparseMulitvariatePolynomial} extends
-the constructor {\bf SparseMultivariatePolynomial}. It also provides
-some additional operations related to polynomial system solving
-by means of triangular sets.
-\section{domain NSMP NewSparseMultivariatePolynomial}
-<<domain NSMP NewSparseMultivariatePolynomial>>=
-)abbrev domain NSMP NewSparseMultivariatePolynomial
-++ Author: Marc Moreno Maza
-++ Date Created: 22/04/94
-++ Date Last Updated: 14/12/1998
-++ Basic Operations: 
-++ Related Domains:
-++ Also See:
-++ AMS Classifications:
-++ Keywords: 
-++ Examples:
-++ References:
-++ Description: A post-facto extension for \axiomType{SMP} in order
-++ to speed up operations related to pseudo-division and gcd.
-++ This domain is based on the \axiomType{NSUP} constructor which is 
-++ itself a post-facto extension of the \axiomType{SUP} constructor.
-++ Version: 2
-
-NewSparseMultivariatePolynomial(R,VarSet) : Exports == Implementation where
-  R:Ring
-  VarSet:OrderedSet
-  N ==> NonNegativeInteger
-  Z ==> Integer
-  SUP ==> NewSparseUnivariatePolynomial
-  SMPR ==> SparseMultivariatePolynomial(R, VarSet)
-  SUP2 ==> NewSparseUnivariatePolynomialFunctions2($,$)
-
-  Exports == Join(RecursivePolynomialCategory(R,IndexedExponents VarSet, VarSet),
-                  CoercibleTo(SMPR),RetractableTo(SMPR))
-
-  Implementation ==  SparseMultivariatePolynomial(R, VarSet) add
-
-     D := NewSparseUnivariatePolynomial($)
-     VPoly:=  Record(v:VarSet,ts:D)
-     Rep:= Union(R,VPoly)
-
-    --local function
-     PSimp: (D,VarSet) -> %
-
-     PSimp(up,mv) ==
-       if degree(up) = 0 then leadingCoefficient(up) else [mv,up]$VPoly
-
-     coerce (p:$):SMPR == 
-       p pretend SMPR
-
-     coerce (p:SMPR):$ == 
-       p pretend $
-
-     retractIfCan (p:$) : Union(SMPR,"failed") == 
-       (p pretend SMPR)::Union(SMPR,"failed")
-
-     mvar p == 
-       p case R => error" Error in mvar from NSMP : #1 has no variables."
-       p.v
-
-     mdeg p == 
-       p case R => 0$N
-       degree(p.ts)$D
-
-     init p == 
-       p case R => error" Error in init from NSMP : #1 has no variables."
-       leadingCoefficient(p.ts)$D
-
-     head p == 
-       p case R => p
-       ([p.v,leadingMonomial(p.ts)$D]$VPoly)::Rep
-
-     tail p == 
-       p case R => 0$$
-       red := reductum(p.ts)$D
-       ground?(red)$D => (ground(red)$D)::Rep
-       ([p.v,red]$VPoly)::Rep
-
-     iteratedInitials p == 
-       p case R => [] 
-       p := leadingCoefficient(p.ts)$D
-       cons(p,iteratedInitials(p)) 
-
-     localDeepestInitial (p : $) : $ == 
-       p case R => p 
-       localDeepestInitial leadingCoefficient(p.ts)$D 
-
-     deepestInitial p == 
-       p case R => error"Error in deepestInitial from NSMP : #1 has no variables."
-       localDeepestInitial leadingCoefficient(p.ts)$D  
-
-     mainMonomial p == 
-       zero? p => error"Error in mainMonomial from NSMP : the argument is zero"
-       p case R => 1$$ 
-       monomial(1$$,p.v,degree(p.ts)$D)
-
-     leastMonomial p == 
-       zero? p => error"Error in leastMonomial from NSMP : the argument is zero"
-       p case R => 1$$
-       monomial(1$$,p.v,minimumDegree(p.ts)$D)
-
-     mainCoefficients p == 
-       zero? p => error"Error in mainCoefficients from NSMP : the argument is zero"
-       p case R => [p]
-       coefficients(p.ts)$D
-
-     leadingCoefficient(p:$,x:VarSet):$ == 
-       (p case R) => p
-       p.v = x => leadingCoefficient(p.ts)$D
-       zero? (d := degree(p,x)) => p
-       coefficient(p,x,d)
-
-     localMonicModulo(a:$,b:$):$ ==
-       -- b is assumed to have initial 1
-       a case R => a
-       a.v < b.v => a 
-       mM: $
-       if a.v > b.v
-         then 
-           m : D := map(localMonicModulo(#1,b),a.ts)$SUP2
-         else
-           m : D := monicModulo(a.ts,b.ts)$D
-       if ground?(m)$D 
-          then 
-            mM := (ground(m)$D)::Rep 
-          else 
-            mM := ([a.v,m]$VPoly)::Rep
-       mM
-
-     monicModulo (a,b) == 
-       b case R => error"Error in monicModulo from NSMP : #2 is constant"
-       ib : $ := init(b)@$
-       not ground?(ib)$$ => 
-         error"Error in monicModulo from NSMP : #2 is not monic"
-       mM : $
---       if not one?(ib)$$
-       if not ((ib) = 1)$$
-         then
-           r : R := ground(ib)$$
-           rec : Union(R,"failed"):= recip(r)$R
-           (rec case "failed") =>
-             error"Error in monicModulo from NSMP : #2 is not monic"
-           a case R => a
-           a := (rec::R) * a
-           b := (rec::R) * b
-           mM := ib * localMonicModulo (a,b)
-         else
-           mM := localMonicModulo (a,b)
-       mM
-
-     prem(a:$, b:$): $ == 
-       -- with pseudoRemainder$NSUP
-       b case R =>
-         error "in prem$NSMP: ground? #2"
-       db: N := degree(b.ts)$D
-       lcb: $ := leadingCoefficient(b.ts)$D
-       test: Z := degree(a,b.v)::Z - db
-       delta: Z := max(test + 1$Z, 0$Z)
-       (a case R) or (a.v < b.v) => lcb ** (delta::N) * a
-       a.v = b.v =>
-         r: D := pseudoRemainder(a.ts,b.ts)$D
-         ground?(r) => return (ground(r)$D)::Rep 
-         ([a.v,r]$VPoly)::Rep
-       while not zero?(a) and not negative?(test) repeat 
-         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
-         a := lcb * a - term * b
-         delta := delta - 1$Z 
-         test := degree(a,b.v)::Z - db
-       lcb ** (delta::N) * a
-
-     pquo (a:$, b:$)  : $ == 
-       cPS := lazyPseudoDivide (a,b)
-       c := (cPS.coef) ** (cPS.gap)
-       c * cPS.quotient
-
-     pseudoDivide(a:$, b:$): Record (quotient : $, remainder : $) ==
-       -- from RPOLCAT
-       cPS := lazyPseudoDivide(a,b)
-       c := (cPS.coef) ** (cPS.gap)
-       [c * cPS.quotient, c * cPS.remainder]
-
-     lazyPrem(a:$, b:$): $ == 
-       -- with lazyPseudoRemainder$NSUP
-       -- Uses leadingCoefficient: ($, V) -> $
-       b case R =>
-         error "in lazyPrem$NSMP: ground? #2"
-       (a case R) or (a.v < b.v) =>  a
-       a.v = b.v => PSimp(lazyPseudoRemainder(a.ts,b.ts)$D,a.v)
-       db: N := degree(b.ts)$D
-       lcb: $ := leadingCoefficient(b.ts)$D
-       test: Z := degree(a,b.v)::Z - db
-       while not zero?(a) and not negative?(test) repeat 
-         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
-         a := lcb * a - term * b
-         test := degree(a,b.v)::Z - db
-       a
-
-     lazyPquo (a:$, b:$) : $ ==
-       -- with lazyPseudoQuotient$NSUP
-       b case R =>
-         error " in lazyPquo$NSMP: #2 is conctant"
-       (a case R) or (a.v < b.v) => 0
-       a.v = b.v => PSimp(lazyPseudoQuotient(a.ts,b.ts)$D,a.v)
-       db: N := degree(b.ts)$D
-       lcb: $ := leadingCoefficient(b.ts)$D
-       test: Z := degree(a,b.v)::Z - db
-       q := 0$$
-       test: Z := degree(a,b.v)::Z - db
-       while not zero?(a) and not negative?(test) repeat 
-         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
-         a := lcb * a - term * b
-         q := lcb * q + term
-         test := degree(a,b.v)::Z - db
-       q
-
-     lazyPseudoDivide(a:$, b:$): Record(coef:$, gap: N,quotient:$, remainder:$) == 
-       -- with lazyPseudoDivide$NSUP
-       b case R =>
-         error " in lazyPseudoDivide$NSMP: #2 is conctant"
-       (a case R) or (a.v < b.v) => [1$$,0$N,0$$,a]
-       a.v = b.v =>
-         cgqr := lazyPseudoDivide(a.ts,b.ts)
-         [cgqr.coef, cgqr.gap, PSimp(cgqr.quotient,a.v), PSimp(cgqr.remainder,a.v)]
-       db: N := degree(b.ts)$D
-       lcb: $ := leadingCoefficient(b.ts)$D
-       test: Z := degree(a,b.v)::Z - db
-       q := 0$$
-       delta: Z := max(test + 1$Z, 0$Z) 
-       while not zero?(a) and not negative?(test) repeat 
-         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
-         a := lcb * a - term * b
-         q := lcb * q + term
-         delta := delta - 1$Z 
-         test := degree(a,b.v)::Z - db
-       [lcb, (delta::N), q, a]
-
-     lazyResidueClass(a:$, b:$): Record(polnum:$, polden:$, power:N) == 
-       -- with lazyResidueClass$NSUP
-       b case R =>
-         error " in lazyResidueClass$NSMP: #2 is conctant"
-       lcb: $ := leadingCoefficient(b.ts)$D
-       (a case R) or (a.v < b.v) => [a,lcb,0]
-       a.v = b.v =>
-         lrc := lazyResidueClass(a.ts,b.ts)$D
-         [PSimp(lrc.polnum,a.v), lrc.polden, lrc.power]
-       db: N := degree(b.ts)$D
-       test: Z := degree(a,b.v)::Z - db
-       pow: N := 0
-       while not zero?(a) and not negative?(test) repeat 
-         term := monomial(leadingCoefficient(a,b.v),b.v,test::N)
-         a := lcb * a - term * b
-         pow := pow + 1
-         test := degree(a,b.v)::Z - db
-       [a, lcb, pow]
-
-     if R has IntegralDomain
-     then
-
-       packD := PseudoRemainderSequence($,D)
-
-       exactQuo(x:$, y:$):$ == 
-         ex: Union($,"failed") := x exquo$$ y
-         (ex case $) => ex::$
-         error "in exactQuotient$NSMP: bad args"
-
-       LazardQuotient(x:$, y:$, n: N):$ == 
-         zero?(n) => error("LazardQuotient$NSMP : n = 0")
---         one?(n) => x
-         (n = 1) => x
-         a: N := 1
-         while n >= (b := 2*a) repeat a := b
-         c: $ := x
-         n := (n - a)::N
-         repeat       
---           one?(a) => return c
-           (a = 1) => return c
-           a := a quo 2
-           c := exactQuo(c*c,y)
-           if n >= a then ( c := exactQuo(c*x,y) ; n := (n - a)::N )
-
-       LazardQuotient2(p:$, a:$, b:$, n: N) ==
-         zero?(n) => error " in LazardQuotient2$NSMP: bad #4"
---         one?(n) => p
-         (n = 1) => p
-         c: $  := LazardQuotient(a,b,(n-1)::N)
-         exactQuo(c*p,b)
-
-       next_subResultant2(p:$, q:$, z:$, s:$) ==
-         PSimp(next_sousResultant2(p.ts,q.ts,z.ts,s)$packD,p.v)
-
-       subResultantGcd(a:$, b:$): $ ==
-         (a case R) or (b case R) => 
-           error "subResultantGcd$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "subResultantGcd$NSMP: mvar(#1) ~= mvar(#2)"
-         PSimp(subResultantGcd(a.ts,b.ts),a.v)
-
-       halfExtendedSubResultantGcd1(a:$,b:$): Record (gcd: $, coef1: $) ==
-         (a case R) or (b case R) => 
-           error "halfExtendedSubResultantGcd1$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "halfExtendedSubResultantGcd1$NSMP: mvar(#1) ~= mvar(#2)"
-         hesrg := halfExtendedSubResultantGcd1(a.ts,b.ts)$D
-         [PSimp(hesrg.gcd,a.v), PSimp(hesrg.coef1,a.v)]
-
-       halfExtendedSubResultantGcd2(a:$,b:$): Record (gcd: $, coef2: $) ==
-         (a case R) or (b case R) => 
-           error "halfExtendedSubResultantGcd2$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "halfExtendedSubResultantGcd2$NSMP: mvar(#1) ~= mvar(#2)"
-         hesrg := halfExtendedSubResultantGcd2(a.ts,b.ts)$D
-         [PSimp(hesrg.gcd,a.v), PSimp(hesrg.coef2,a.v)]
-
-       extendedSubResultantGcd(a:$,b:$): Record (gcd: $, coef1: $, coef2: $) ==
-         (a case R) or (b case R) => 
-           error "extendedSubResultantGcd$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "extendedSubResultantGcd$NSMP: mvar(#1) ~= mvar(#2)"
-         esrg := extendedSubResultantGcd(a.ts,b.ts)$D
-         [PSimp(esrg.gcd,a.v),PSimp(esrg.coef1,a.v),PSimp(esrg.coef2,a.v)]  
-
-       resultant(a:$, b:$): $ ==
-         (a case R) or (b case R) => 
-           error "resultant$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "resultant$NSMP: mvar(#1) ~= mvar(#2)"
-         resultant(a.ts,b.ts)$D
-
-       subResultantChain(a:$, b:$): List $ ==
-         (a case R) or (b case R) => 
-           error "subResultantChain$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "subResultantChain$NSMP: mvar(#1) ~= mvar(#2)"
-         [PSimp(up,a.v) for up in subResultantsChain(a.ts,b.ts)]
-
-       lastSubResultant(a:$, b:$): $ ==
-         (a case R) or (b case R) => 
-           error "lastSubResultant$NSMP: one arg is constant"
-         a.v ~= b.v => 
-           error "lastSubResultant$NSMP: mvar(#1) ~= mvar(#2)"
-         PSimp(lastSubResultant(a.ts,b.ts),a.v)
-
-       if R has EuclideanDomain
-       then
-
-         exactQuotient (a:$,b:R) ==
---           one? b => a
-           (b = 1) => a
-           a case R => (a::R quo$R b)::$
-           ([a.v, map(exactQuotient(#1,b),a.ts)$SUP2]$VPoly)::Rep
-
-         exactQuotient! (a:$,b:R) ==
---           one? b => a
-           (b = 1) => a
-           a case R => (a::R quo$R b)::$
-           a.ts := map(exactQuotient!(#1,b),a.ts)$SUP2
-           a
-
-       else
-
-         exactQuotient (a:$,b:R) ==
---           one? b => a
-           (b = 1) => a
-           a case R => ((a::R exquo$R b)::R)::$
-           ([a.v, map(exactQuotient(#1,b),a.ts)$SUP2]$VPoly)::Rep
-
-         exactQuotient! (a:$,b:R) == 
---           one? b => a
-           (b = 1) => a
-           a case R => ((a::R exquo$R b)::R)::$
-           a.ts := map(exactQuotient!(#1,b),a.ts)$SUP2
-           a
-
-     if R has GcdDomain
-     then
-
-       localGcd(r:R,p:$):R ==
-         p case R => gcd(r,p::R)$R
-         gcd(r,content(p))$R         
-
-       gcd(r:R,p:$):R ==
---         one? r => r
-         (r = 1) => r
-         zero? p => r
-         localGcd(r,p)
-
-       content p ==
-         p case R => p
-         up : D := p.ts
-         r := 0$R
---         while (not zero? up) and (not one? r) repeat
-         while (not zero? up) and (not (r = 1)) repeat
-           r := localGcd(r,leadingCoefficient(up))
-           up := reductum up
-         r
-
-       primitivePart! p ==
-         zero? p => p
-         p case R => 1$$
-         cp := content(p)
-         p.ts := unitCanonical(map(exactQuotient!(#1,cp),p.ts)$SUP2)$D
-         p
-
-@
 \section{License}
 <<license>>=
 --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
@@ -738,9 +74,7 @@ NewSparseMultivariatePolynomial(R,VarSet) : Exports == Implementation where
 <<*>>=
 <<license>>
 
-<<domain NSUP NewSparseUnivariatePolynomial>>
 <<package NSUP2 NewSparseUnivariatePolynomialFunctions2>>
-<<domain NSMP NewSparseMultivariatePolynomial>>
 @
 \eject
 \begin{thebibliography}{99}
diff --git a/src/algebra/oct.spad.pamphlet b/src/algebra/oct.spad.pamphlet
index 98a3da0..a5383c0 100644
--- a/src/algebra/oct.spad.pamphlet
+++ b/src/algebra/oct.spad.pamphlet
@@ -10,379 +10,6 @@
 \eject
 \tableofcontents
 \eject
-\section{domain OCT Octonion}
-The octonions have the following multiplication table:
-$$
-\begin{array}{|r|r|r|r|r|r|r|r|}
-\hline
-1 &   i &   j &   k &   E &   I &   J &   K\\
-\hline
-i & - 1 &   k & - j &   I & - E & - K &   J\\
-\hline
-j & - k & - 1 &   i &   J &   K & - E & - I\\
-\hline
-k &   j & - i & - 1 &   K & - J &   I & - E\\
-\hline
-E & - I & - J & - K & - 1 &   i &   j &   k\\
-\hline
-I &   E & - K &   J & - i & - 1 & - k &   j\\
-\hline
-J &   K &   E & - I & - j &   k & - 1 & - i\\
-\hline
-K & - J &   I &   E & - k & - j &   i & - 1\\
-\hline
-\end{array}
-$$
-
-There are 3 different kinds of associativity. An algebra is
-\begin{itemize}
-\item {\bf power-associative} 
-if the subalgebra generated by any one element is associative.
-That is, given any element $e$ then $e*(e*e) = (e*e)*e$.
-\item {\bf alternative} 
-if the subalgebra generated by any two elements is associative
-That is, given any two elements, $a$ and $b$ then 
-$a*(a*b) = (a*a)*b$ and 
-$a*(b*a) = (a*b)*a$ and
-$b*(a*a) = (b*a)*a$.
-\item {\bf associative}
-if the subalgebra generated by any three elements is associative.
-That is, given any three elements $a$, $b$, and $c$ then
-$a*(b*c) = (a*b)*c$. 
-\end{itemize}
-The Octonions are power-associative and alternative but not
-associative, since $I*(J*K) \ne (I*J)*K$.
-
-\begin{pspicture}(0,0)(4,4)
-% draw and label the nodes
-\rput(3,2){\circlenode{e3}{\huge {\bf $e_3$}}}
-\rput(6,2){\circlenode{e2}{\huge {\bf $e_2$}}}
-\rput(9,2){\circlenode{e5}{\huge {\bf $e_5$}}}
-\rput(6,3.5){\circlenode{e7}{\huge {\bf $e_7$}}}
-\rput(4.5,4.1){\circlenode{e4}{\huge {\bf $e_4$}}}
-\rput(7.5,4.1){\circlenode{e1}{\huge {\bf $e_1$}}}
-\rput(6,6){\circlenode{e6}{\huge {\bf $e_6$}}}
-% around the outside
-\ncline{->}{e3}{e4}
-\ncline{->}{e4}{e6}
-\ncline{->}{e6}{e1}
-\ncline{->}{e1}{e5}
-\ncline{->}{e5}{e2}
-\ncline{->}{e2}{e3}
-% inside
-\ncline{->}{e3}{e7}
-\ncline{->}{e7}{e2}
-\ncline{->}{e5}{e7}
-\ncline{->}{e7}{e1}
-\ncline{->}{e6}{e7}
-\ncline{->}{e7}{e4}
-% the arcs
-\ncarc{->}{e2}{e4}
-\ncarc{->}{e4}{e1}
-\ncarc{->}{e1}{e2}
-\end{pspicture}
-<<Octonion.input>>=
--- oct.spad.pamphlet Octonion.input
-)spool Octonion.output
-)set message test on
-)set message auto off
-)clear all
---S 1 of 15
-oci1 := octon(1,2,3,4,5,6,7,8)
---R 
---R
---R   (1)  1 + 2i + 3j + 4k + 5E + 6I + 7J + 8K
---R                                                       Type: Octonion Integer
---E 1
-
---S 2 of 15
-oci2 := octon(7,2,3,-4,5,6,-7,0)
---R 
---R
---R   (2)  7 + 2i + 3j - 4k + 5E + 6I - 7J
---R                                                       Type: Octonion Integer
---E 2
-
---S 3 of 15
-oci3 := octon(quatern(-7,-12,3,-10), quatern(5,6,9,0))
---R 
---R
---R   (3)  - 7 - 12i + 3j - 10k + 5E + 6I + 9J
---R                                                       Type: Octonion Integer
---E 3
-
---S 4 of 15
-(oci1 * oci2) * oci3 - oci1 * (oci2 * oci3)
---R 
---R
---R   (4)  2696i - 2928j - 4072k + 16E - 1192I + 832J + 2616K
---R                                                       Type: Octonion Integer
---E 4
-
---S 5 of 15
-[real oci1, imagi oci1, imagj oci1, imagk oci1, _
- imagE oci1, imagI oci1, imagJ oci1, imagK oci1]
---R 
---R
---R   (5)  [1,2,3,4,5,6,7,8]
---R                                                   Type: List PositiveInteger
---E 5
-
---S 6 of 15
-q : Quaternion Polynomial Integer := quatern(q1, qi, qj, qk)
---R 
---R
---R   (6)  q1 + qi i + qj j + qk k
---R                                          Type: Quaternion Polynomial Integer
---E 6
-
---S 7 of 15
-E : Octonion Polynomial Integer:= octon(0,0,0,0,1,0,0,0)
---R 
---R
---R   (7)  E
---R                                            Type: Octonion Polynomial Integer
---E 7
-
---S 8 of 15
-q * E
---R 
---R
---R   (8)  q1 E + qi I + qj J + qk K
---R                                            Type: Octonion Polynomial Integer
---E 8
-
---S 9 of 15
-E * q
---R 
---R
---R   (9)  q1 E - qi I - qj J - qk K
---R                                            Type: Octonion Polynomial Integer
---E 9
-
---S 10 of 15
-q * 1$(Octonion Polynomial Integer)
---R 
---R
---R   (10)  q1 + qi i + qj j + qk k
---R                                            Type: Octonion Polynomial Integer
---E 10
-
---S 11 of 15
-1$(Octonion Polynomial Integer) * q
---R 
---R
---R   (11)  q1 + qi i + qj j + qk k
---R                                            Type: Octonion Polynomial Integer
---E 11
-
---S 12 of 15
-o : Octonion Polynomial Integer := octon(o1, oi, oj, ok, oE, oI, oJ, oK)
---R 
---R
---R   (12)  o1 + oi i + oj j + ok k + oE E + oI I + oJ J + oK K
---R                                            Type: Octonion Polynomial Integer
---E 12
-
---S 13 of 15
-norm o
---R 
---R
---R           2     2     2     2     2     2     2     2
---R   (13)  ok  + oj  + oi  + oK  + oJ  + oI  + oE  + o1
---R                                                     Type: Polynomial Integer
---E 13
-
---S 14 of 15
-p : Octonion Polynomial Integer := octon(p1, pi, pj, pk, pE, pI, pJ, pK)
---R 
---R
---R   (14)  p1 + pi i + pj j + pk k + pE E + pI I + pJ J + pK K
---R                                            Type: Octonion Polynomial Integer
---E 14
-
---S 15 of 15
-norm(o*p)-norm(p)*norm(o)
---R 
---R
---R   (15)  0
---R                                                     Type: Polynomial Integer
---E 15
-)spool
-)lisp (bye)
-@
-<<Octonion.help>>=
-====================================================================
-Octonion examples
-====================================================================
-
-The Octonions, also called the Cayley-Dixon algebra, defined over a
-commutative ring are an eight-dimensional non-associative algebra.
-Their construction from quaternions is similar to the construction
-of quaternions from complex numbers.
-
-As Octonion creates an eight-dimensional algebra, you have to give
-eight components to construct an octonion.
-
-  oci1 := octon(1,2,3,4,5,6,7,8)
-    1 + 2i + 3j + 4k + 5E + 6I + 7J + 8K
-                              Type: Octonion Integer
-
-  oci2 := octon(7,2,3,-4,5,6,-7,0)
-    7 + 2i + 3j - 4k + 5E + 6I - 7J
-                              Type: Octonion Integer
-
-Or you can use two quaternions to create an octonion.
-
-  oci3 := octon(quatern(-7,-12,3,-10), quatern(5,6,9,0))
-    - 7 - 12i + 3j - 10k + 5E + 6I + 9J
-                              Type: Octonion Integer
-
-You can easily demonstrate the non-associativity of multiplication.
-
-  (oci1 * oci2) * oci3 - oci1 * (oci2 * oci3)
-    2696i - 2928j - 4072k + 16E - 1192I + 832J + 2616K
-                              Type: Octonion Integer
-
-As with the quaternions, we have a real part, the imaginary parts 
-i, j, k, and four additional imaginary parts E, I, J and K. These 
-parts correspond to the canonical basis (1,i,j,k,E,I,J,K).
-
-For each basis element there is a component operation to extract the
-coefficient of the basis element for a given octonion.
-
-  [real oci1, imagi oci1, imagj oci1, imagk oci1, _
-   imagE oci1, imagI oci1, imagJ oci1, imagK oci1]
-    [1,2,3,4,5,6,7,8]
-                              Type: List PositiveInteger
-
-A basis with respect to the quaternions is given by (1,E).  However,
-you might ask, what then are the commuting rules?  To answer this, we
-create some generic elements.
-
-We do this in Axiom by simply changing the ground ring from Integer to
-Polynomial Integer.
-
-  q : Quaternion Polynomial Integer := quatern(q1, qi, qj, qk)
-    q1 + qi i + qj j + qk k
-                             Type: Quaternion Polynomial Integer
-
-  E : Octonion Polynomial Integer:= octon(0,0,0,0,1,0,0,0)
-    E
-                             Type: Octonion Polynomial Integer
-
-Note that quaternions are automatically converted to octonions in the
-obvious way.
-
-  q * E
-    q1 E + qi I + qj J + qk K
-                             Type: Octonion Polynomial Integer
-
-  E * q
-    q1 E - qi I - qj J - qk K
-                             Type: Octonion Polynomial Integer
-
-  q * 1$(Octonion Polynomial Integer)
-    q1 + qi i + qj j + qk k
-                             Type: Octonion Polynomial Integer
-
-  1$(Octonion Polynomial Integer) * q
-    q1 + qi i + qj j + qk k
-                             Type: Octonion Polynomial Integer
-
-Finally, we check that the norm, defined as the sum of the squares of
-the coefficients, is a multiplicative map.
-
-  o : Octonion Polynomial Integer := octon(o1, oi, oj, ok, oE, oI, oJ, oK)
-    o1 + oi i + oj j + ok k + oE E + oI I + oJ J + oK K
-                             Type: Octonion Polynomial Integer
-
-  norm o
-      2     2     2     2     2     2     2     2
-    ok  + oj  + oi  + oK  + oJ  + oI  + oE  + o1
-                             Type: Polynomial Integer
-
-  p : Octonion Polynomial Integer := octon(p1, pi, pj, pk, pE, pI, pJ, pK)
-    p1 + pi i + pj j + pk k + pE E + pI I + pJ J + pK K
-                             Type: Octonion Polynomial Integer
-
-Since the result is 0, the norm is multiplicative.
-
-  norm(o*p)-norm(p)*norm(o)
-    0
-                             Type: Polynomial Integer
-
-See Also:
-o )help Quaternion
-o )show Octonion
-o $AXIOM/doc/src/algebra/oct.spad.dvi
-
-@
-<<domain OCT Octonion>>=
-)abbrev domain OCT Octonion
-++ Author: R. Wisbauer, J. Grabmeier
-++ Date Created: 05 September 1990
-++ Date Last Updated: 20 September 1990
-++ Basic Operations: _+,_*,octon,image,imagi,imagj,imagk,
-++  imagE,imagI,imagJ,imagK
-++ Related Constructors: Quaternion
-++ Also See: AlgebraGivenByStructuralConstants
-++ AMS Classifications:
-++ Keywords: octonion, non-associative algebra, Cayley-Dixon  
-++ References: e.g. I.L Kantor, A.S. Solodovnikov:
-++  Hypercomplex Numbers, Springer Verlag Heidelberg, 1989,
-++  ISBN 0-387-96980-2
-++ Description:
-++  Octonion implements octonions (Cayley-Dixon algebra) over a
-++  commutative ring, an eight-dimensional non-associative
-++  algebra, doubling the quaternions in the same way as doubling
-++  the complex numbers to get the quaternions 
-++  the main constructor function is {\em octon} which takes 8
-++  arguments: the real part, the i imaginary part, the j 
-++  imaginary part, the k imaginary part, (as with quaternions)
-++  and in addition the imaginary parts E, I, J, K.
--- Examples: octonion.input
---)boot $noSubsumption := true
-Octonion(R:CommutativeRing): export == impl where
- 
-  QR ==> Quaternion R
- 
-  export ==> Join(OctonionCategory R, FullyRetractableTo QR)  with
-    octon: (QR,QR) -> %
-      ++ octon(qe,qE) constructs an octonion from two quaternions
-      ++ using the relation {\em O = Q + QE}.
-  impl ==> add
-    Rep := Record(e: QR,E: QR)
- 
-    0 == [0,0]
-    1 == [1,0]
- 
-    a,b,c,d,f,g,h,i : R
-    p,q : QR
-    x,y : %
- 
-    real  x == real (x.e)
-    imagi x == imagI (x.e)
-    imagj x == imagJ (x.e)
-    imagk x == imagK (x.e)
-    imagE x == real (x.E)
-    imagI x == imagI (x.E)
-    imagJ x == imagJ (x.E)
-    imagK x == imagK (x.E)
-    octon(a,b,c,d,f,g,h,i) == [quatern(a,b,c,d)$QR,quatern(f,g,h,i)$QR]
-    octon(p,q) == [p,q]
-    coerce(q) == [q,0$QR] 
-    retract(x):QR ==
-      not(zero? imagE x and zero? imagI x and zero? imagJ x and zero? imagK x)=>
-        error "Cannot retract octonion to quaternion."
-      quatern(real x, imagi x,imagj x, imagk x)$QR
-    retractIfCan(x):Union(QR,"failed") ==
-      not(zero? imagE x and zero? imagI x and zero? imagJ x and zero? imagK x)=>
-        "failed"
-      quatern(real x, imagi x,imagj x, imagk x)$QR
-    x * y == [x.e*y.e-(conjugate y.E)*x.E, y.E*x.e + x.E*(conjugate y.e)]
-
-@
 \section{package OCTCT2 OctonionCategoryFunctions2}
 <<package OCTCT2 OctonionCategoryFunctions2>>=
 )abbrev package OCTCT2 OctonionCategoryFunctions2
@@ -454,7 +81,6 @@ OctonionCategoryFunctions2(OR,R,OS,S) : Exports ==
 <<*>>=
 <<license>>
 
-<<domain OCT Octonion>>
 <<package OCTCT2 OctonionCategoryFunctions2>>
 @
 \eject
diff --git a/src/algebra/omdev.spad.pamphlet b/src/algebra/omdev.spad.pamphlet
index 070de7b..bea83ea 100644
--- a/src/algebra/omdev.spad.pamphlet
+++ b/src/algebra/omdev.spad.pamphlet
@@ -9,256 +9,6 @@
 \eject
 \tableofcontents
 \eject
-\section{domain OMENC OpenMathEncoding}
-<<domain OMENC OpenMathEncoding>>=
-)abbrev domain OMENC OpenMathEncoding
-++ Author: Vilya Harvey
-++ Date Created:
-++ Date Last Updated:
-++ Basic Functions: 
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++ Description:
-++ \spadtype{OpenMathEncoding} is the set of valid OpenMath encodings.
-OpenMathEncoding(): SetCategory with
-  OMencodingUnknown : () -> %
-  ++ OMencodingUnknown() is the constant for unknown encoding types. If this 
-  ++ is used on an input device, the encoding will be autodetected.
-  ++ It is invalid to use it on an output device.
-  OMencodingXML     : () -> %
-  ++ OMencodingXML() is the constant for the OpenMath XML encoding.
-  OMencodingSGML    : () -> %
-  ++ OMencodingSGML() is the constant for the deprecated OpenMath SGML encoding.
-  OMencodingBinary  : () -> %
-  ++ OMencodingBinary() is the constant for the OpenMath binary encoding.
- == add
-  Rep := SingleInteger
-
-  =(u,v) == (u=v)$Rep
-
-  import Rep
-
-  coerce(u) ==
-    u::Rep = 0$Rep => "Unknown"::OutputForm
-    u::Rep = 1$Rep => "Binary"::OutputForm
-    u::Rep = 2::Rep => "XML"::OutputForm
-    u::Rep = 3::Rep => "SGML"::OutputForm
-    error "Bogus OpenMath Encoding Type"
-
-  OMencodingUnknown(): % == 0::Rep
-  OMencodingBinary(): % == 1::Rep
-  OMencodingXML(): % == 2::Rep
-  OMencodingSGML(): % == 3::Rep
-
-@
-\section{domain OMDEV OpenMathDevice}
-<<domain OMDEV OpenMathDevice>>=
-)abbrev domain OMDEV OpenMathDevice
-++ Author: Vilya Harvey
-++ Date Created:
-++ Date Last Updated:
-++ Basic Functions:
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++ Description: \spadtype{OpenMathDevice} provides support for reading
-++ and writing openMath objects to files, strings etc.  It also provides
-++ access to low-level operations from within the interpreter.
-
-
-OpenMathDevice(): with
-  OMopenFile    : (String, String, OpenMathEncoding) -> %
-  ++ OMopenFile(f,mode,enc) opens file \axiom{f} for reading or writing
-  ++ OpenMath objects (depending on \axiom{mode} which can be "r", "w"
-  ++ or "a" for read, write and append respectively), in the encoding
-  ++ \axiom{enc}.
-  OMopenString  : (String, OpenMathEncoding) -> %
-  ++ OMopenString(s,mode) opens the string \axiom{s} for reading or writing 
-  ++ OpenMath objects in encoding \axiom{enc}.
-  OMclose       : % -> Void
-  ++ OMclose(dev) closes \axiom{dev}, flushing output if necessary.
-  OMsetEncoding : (%, OpenMathEncoding) -> Void
-  ++ OMsetEncoding(dev,enc) sets the encoding used for reading or writing
-  ++ OpenMath objects to or from \axiom{dev} to \axiom{enc}.
-  OMputApp      : % -> Void
-  ++ OMputApp(dev) writes a begin application token to \axiom{dev}.
-  OMputAtp      : % -> Void
-  ++ OMputAtp(dev) writes a begin attribute pair token to \axiom{dev}.
-  OMputAttr     : % -> Void
-  ++ OMputAttr(dev) writes a begin attribute token to \axiom{dev}.
-  OMputBind     : % -> Void
-  ++ OMputBind(dev) writes a begin binder token to \axiom{dev}.
-  OMputBVar     : % -> Void
-  ++ OMputBVar(dev) writes a begin bound variable list token to \axiom{dev}.
-  OMputError    : % -> Void
-  ++ OMputError(dev) writes a begin error token to \axiom{dev}.
-  OMputObject   : % -> Void
-  ++ OMputObject(dev) writes a begin object token to \axiom{dev}.
-  OMputEndApp   : % -> Void
-  ++ OMputEndApp(dev) writes an end application token to \axiom{dev}.
-  OMputEndAtp   : % -> Void
-  ++ OMputEndAtp(dev) writes an end attribute pair token to \axiom{dev}.
-  OMputEndAttr  : % -> Void
-  ++ OMputEndAttr(dev) writes an end attribute token to \axiom{dev}.
-  OMputEndBind  : % -> Void
-  ++ OMputEndBind(dev) writes an end binder token to \axiom{dev}.
-  OMputEndBVar  : % -> Void
-  ++ OMputEndBVar(dev) writes an end bound variable list token to \axiom{dev}.
-  OMputEndError : % -> Void
-  ++ OMputEndError(dev) writes an end error token to \axiom{dev}.
-  OMputEndObject: % -> Void
-  ++ OMputEndObject(dev) writes an end object token to \axiom{dev}.
-  OMputInteger  : (%, Integer) -> Void
-  ++ OMputInteger(dev,i) writes the integer \axiom{i} to \axiom{dev}.
-  OMputFloat    : (%, DoubleFloat) -> Void
-  ++ OMputFloat(dev,i) writes the float \axiom{i} to \axiom{dev}.
-  OMputVariable : (%, Symbol) -> Void
-  ++ OMputVariable(dev,i) writes the variable \axiom{i} to \axiom{dev}.
-  OMputString   : (%, String) -> Void
-  ++ OMputString(dev,i) writes the string \axiom{i} to \axiom{dev}.
-  OMputSymbol   : (%, String, String) -> Void
-  ++ OMputSymbol(dev,cd,s) writes the symbol \axiom{s} from CD \axiom{cd}
-  ++ to \axiom{dev}.
-
-  OMgetApp      : % -> Void
-  ++ OMgetApp(dev) reads a begin application token from \axiom{dev}.
-  OMgetAtp      : % -> Void
-  ++ OMgetAtp(dev) reads a begin attribute pair token from \axiom{dev}.
-  OMgetAttr     : % -> Void
-  ++ OMgetAttr(dev) reads a begin attribute token from \axiom{dev}.
-  OMgetBind     : % -> Void
-  ++ OMgetBind(dev) reads a begin binder token from \axiom{dev}.
-  OMgetBVar     : % -> Void
-  ++ OMgetBVar(dev) reads a begin bound variable list token from \axiom{dev}.
-  OMgetError    : % -> Void
-  ++ OMgetError(dev) reads a begin error token from \axiom{dev}.
-  OMgetObject   : % -> Void
-  ++ OMgetObject(dev) reads a begin object token from \axiom{dev}.
-  OMgetEndApp   : % -> Void
-  ++ OMgetEndApp(dev) reads an end application token from \axiom{dev}.
-  OMgetEndAtp   : % -> Void
-  ++ OMgetEndAtp(dev) reads an end attribute pair token from \axiom{dev}.
-  OMgetEndAttr  : % -> Void
-  ++ OMgetEndAttr(dev) reads an end attribute token from \axiom{dev}.
-  OMgetEndBind  : % -> Void
-  ++ OMgetEndBind(dev) reads an end binder token from \axiom{dev}.
-  OMgetEndBVar  : % -> Void
-  ++ OMgetEndBVar(dev) reads an end bound variable list token from \axiom{dev}.
-  OMgetEndError : % -> Void
-  ++ OMgetEndError(dev) reads an end error token from \axiom{dev}.
-  OMgetEndObject: % -> Void
-  ++ OMgetEndObject(dev) reads an end object token from \axiom{dev}.
-  OMgetInteger  : % -> Integer
-  ++ OMgetInteger(dev) reads an integer from \axiom{dev}.
-  OMgetFloat    : % -> DoubleFloat
-  ++ OMgetFloat(dev) reads a float from \axiom{dev}.
-  OMgetVariable : % -> Symbol
-  ++ OMgetVariable(dev) reads a variable from \axiom{dev}.
-  OMgetString   : % -> String
-  ++ OMgetString(dev) reads a string from \axiom{dev}.
-  OMgetSymbol   : % -> Record(cd:String, name:String)
-  ++ OMgetSymbol(dev) reads a symbol from \axiom{dev}.
-
-  OMgetType     : % -> Symbol
-  ++ OMgetType(dev) returns the type of the next object on \axiom{dev}.
- == add
-  OMopenFile(fname: String, fmode: String, enc: OpenMathEncoding): % ==
-    OM_-OPENFILEDEV(fname, fmode, enc)$Lisp
-  OMopenString(str: String, enc: OpenMathEncoding): % ==
-    OM_-OPENSTRINGDEV(str, enc)$Lisp
-  OMclose(dev: %): Void ==
-    OM_-CLOSEDEV(dev)$Lisp
-  OMsetEncoding(dev: %, enc: OpenMathEncoding): Void ==
-    OM_-SETDEVENCODING(dev, enc)$Lisp
-
-  OMputApp(dev: %): Void == OM_-PUTAPP(dev)$Lisp
-  OMputAtp(dev: %): Void == OM_-PUTATP(dev)$Lisp
-  OMputAttr(dev: %): Void == OM_-PUTATTR(dev)$Lisp
-  OMputBind(dev: %): Void == OM_-PUTBIND(dev)$Lisp
-  OMputBVar(dev: %): Void == OM_-PUTBVAR(dev)$Lisp
-  OMputError(dev: %): Void == OM_-PUTERROR(dev)$Lisp
-  OMputObject(dev: %): Void == OM_-PUTOBJECT(dev)$Lisp
-  OMputEndApp(dev: %): Void == OM_-PUTENDAPP(dev)$Lisp
-  OMputEndAtp(dev: %): Void == OM_-PUTENDATP(dev)$Lisp
-  OMputEndAttr(dev: %): Void == OM_-PUTENDATTR(dev)$Lisp
-  OMputEndBind(dev: %): Void == OM_-PUTENDBIND(dev)$Lisp
-  OMputEndBVar(dev: %): Void == OM_-PUTENDBVAR(dev)$Lisp
-  OMputEndError(dev: %): Void == OM_-PUTENDERROR(dev)$Lisp
-  OMputEndObject(dev: %): Void == OM_-PUTENDOBJECT(dev)$Lisp
-  OMputInteger(dev: %, i: Integer): Void == OM_-PUTINT(dev, i)$Lisp
-  OMputFloat(dev: %, f: DoubleFloat): Void == OM_-PUTFLOAT(dev, f)$Lisp
-  --OMputByteArray(dev: %, b: Array Byte): Void == OM_-PUTBYTEARRAY(dev, b)$Lisp
-  OMputVariable(dev: %, v: Symbol): Void == OM_-PUTVAR(dev, v)$Lisp
-  OMputString(dev: %, s: String): Void == OM_-PUTSTRING(dev, s)$Lisp
-  OMputSymbol(dev: %, cd: String, nm: String): Void == OM_-PUTSYMBOL(dev, cd, nm)$Lisp
-
-  OMgetApp(dev: %): Void == OM_-GETAPP(dev)$Lisp
-  OMgetAtp(dev: %): Void == OM_-GETATP(dev)$Lisp
-  OMgetAttr(dev: %): Void == OM_-GETATTR(dev)$Lisp
-  OMgetBind(dev: %): Void == OM_-GETBIND(dev)$Lisp
-  OMgetBVar(dev: %): Void == OM_-GETBVAR(dev)$Lisp
-  OMgetError(dev: %): Void == OM_-GETERROR(dev)$Lisp
-  OMgetObject(dev: %): Void == OM_-GETOBJECT(dev)$Lisp
-  OMgetEndApp(dev: %): Void == OM_-GETENDAPP(dev)$Lisp
-  OMgetEndAtp(dev: %): Void == OM_-GETENDATP(dev)$Lisp
-  OMgetEndAttr(dev: %): Void == OM_-GETENDATTR(dev)$Lisp
-  OMgetEndBind(dev: %): Void == OM_-GETENDBIND(dev)$Lisp
-  OMgetEndBVar(dev: %): Void == OM_-GETENDBVAR(dev)$Lisp
-  OMgetEndError(dev: %): Void == OM_-GETENDERROR(dev)$Lisp
-  OMgetEndObject(dev: %): Void == OM_-GETENDOBJECT(dev)$Lisp
-  OMgetInteger(dev: %): Integer == OM_-GETINT(dev)$Lisp
-  OMgetFloat(dev: %): DoubleFloat == OM_-GETFLOAT(dev)$Lisp
-  --OMgetByteArray(dev: %): Array Byte == OM_-GETBYTEARRAY(dev)$Lisp
-  OMgetVariable(dev: %): Symbol == OM_-GETVAR(dev)$Lisp
-  OMgetString(dev: %): String == OM_-GETSTRING(dev)$Lisp
-  OMgetSymbol(dev: %): Record(cd:String, name:String) == OM_-GETSYMBOL(dev)$Lisp
-
-  OMgetType(dev: %): Symbol == OM_-GETTYPE(dev)$Lisp
-
-@
-\section{domain OMCONN OpenMathConnection}
-<<domain OMCONN OpenMathConnection>>=
-)abbrev domain OMCONN OpenMathConnection
-++ Author: Vilya Harvey
-++ Date Created:
-++ Date Last Updated:
-++ Basic Functions:
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++ Description: \spadtype{OpenMathConnection} provides low-level functions
-++ for handling connections to and from \spadtype{OpenMathDevice}s.
-
-
-OpenMathConnection(): with
-  OMmakeConn    : SingleInteger -> % ++ \spad{OMmakeConn}
-  OMcloseConn   : % -> Void ++ \spad{OMcloseConn}
-  OMconnInDevice: %-> OpenMathDevice ++ \spad{OMconnInDevice:}
-  OMconnOutDevice: %-> OpenMathDevice ++ \spad{OMconnOutDevice:}
-  OMconnectTCP  : (%, String, SingleInteger) -> Boolean ++ \spad{OMconnectTCP}
-  OMbindTCP     : (%, SingleInteger) -> Boolean ++ \spad{OMbindTCP}
- == add
-  OMmakeConn(timeout: SingleInteger): % == OM_-MAKECONN(timeout)$Lisp
-  OMcloseConn(conn: %): Void == OM_-CLOSECONN(conn)$Lisp
-
-  OMconnInDevice(conn: %): OpenMathDevice ==
-    OM_-GETCONNINDEV(conn)$Lisp
-  OMconnOutDevice(conn: %): OpenMathDevice ==
-    OM_-GETCONNOUTDEV(conn)$Lisp
-
-  OMconnectTCP(conn: %, host: String, port: SingleInteger): Boolean ==
-    OM_-CONNECTTCP(conn, host, port)$Lisp
-  OMbindTCP(conn: %, port: SingleInteger): Boolean ==
-    OM_-BINDTCP(conn, port)$Lisp
-
-@
 \section{package OMPKG OpenMathPackage}
 <<package OMPKG OpenMathPackage>>=
 )abbrev package OMPKG OpenMathPackage
@@ -373,9 +123,6 @@ OpenMathPackage(): with
 <<*>>=
 <<license>>
 
-<<domain OMENC OpenMathEncoding>>
-<<domain OMDEV OpenMathDevice>>
-<<domain OMCONN OpenMathConnection>>
 <<package OMPKG OpenMathPackage>>
 @
 \eject
diff --git a/src/algebra/omerror.spad.pamphlet b/src/algebra/omerror.spad.pamphlet
deleted file mode 100644
index 410b31d..0000000
--- a/src/algebra/omerror.spad.pamphlet
+++ /dev/null
@@ -1,151 +0,0 @@
-\documentclass{article}
-\usepackage{axiom}
-\begin{document}
-\title{\$SPAD/src/algebra omerror.spad}
-\author{Vilya Harvey}
-\maketitle
-\begin{abstract}
-\end{abstract}
-\eject
-\tableofcontents
-\eject
-\section{domain OMERRK OpenMathErrorKind}
-<<domain OMERRK OpenMathErrorKind>>=
-)abbrev domain OMERRK OpenMathErrorKind
-++ Author: Vilya Harvey
-++ Date Created:
-++ Date Last Updated:
-++ Basic Functions:
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++ Description: \spadtype{OpenMathErrorKind} represents different kinds
-++ of OpenMath errors: specifically parse errors, unknown CD or symbol 
-++ errors, and read errors.
-OpenMathErrorKind() : SetCategory with
-  coerce           : Symbol -> %
-  ++ coerce(u) creates an OpenMath error object of an appropriate type if
-  ++ \axiom{u} is one of \axiom{OMParseError}, \axiom{OMReadError},
-  ++ \axiom{OMUnknownCD} or \axiom{OMUnknownSymbol}, otherwise it
-  ++ raises a runtime error.
-  OMParseError?    : % -> Boolean
-  ++ OMParseError?(u) tests whether u is an OpenMath parsing error.
-  OMUnknownCD?     : % -> Boolean
-  ++ OMUnknownCD?(u) tests whether u is an OpenMath unknown CD error.
-  OMUnknownSymbol? : % -> Boolean
-  ++ OMUnknownSymbol?(u) tests whether u is an OpenMath unknown symbol error.
-  OMReadError?     : % -> Boolean
-  ++ OMReadError?(u) tests whether u is an OpenMath read error.
- == add
-  Rep := Union(parseError:"OMParseError", unknownCD:"OMUnknownCD", 
-               unknownSymbol:"OMUnknownSymbol",readError:"OMReadError")
-
-  OMParseError?(u) == (u case parseError)$Rep
-  OMUnknownCD?(u) == (u case unknownCD)$Rep
-  OMUnknownSymbol?(u) == (u case unknownSymbol)$Rep
-  OMReadError?(u) == (u case readError)$Rep
-
-  coerce(s:Symbol):% == 
-    s = OMParseError    => ["OMParseError"]$Rep
-    s = OMUnknownCD     => ["OMUnknownCD"]$Rep
-    s = OMUnknownSymbol => ["OMUnknownSymbol"]$Rep
-    s = OMReadError     => ["OMReadError"]$Rep
-    error concat(string s, " is not a valid OpenMathErrorKind.")
-
-  a = b == (a=b)$Rep
-
-  coerce(e:%):OutputForm == coerce(e)$Rep
-
-@
-\section{domain OMERR OpenMathError}
-<<domain OMERR OpenMathError>>=
-)abbrev domain OMERR OpenMathError
-++ Author: Vilya Harvey
-++ Date Created:
-++ Date Last Updated:
-++ Basic Functions:
-++ Related Constructors:
-++ Also See:
-++ AMS Classifications:
-++ Keywords:
-++ References:
-++ Description: \spadtype{OpenMathError} is the domain of OpenMath errors.
-OpenMathError() : SetCategory with
-  errorKind : % -> OpenMathErrorKind
-  ++ errorKind(u) returns the type of error which u represents.
-  errorInfo : % -> List Symbol
-  ++ errorInfo(u) returns information about the error u.
-  omError   : (OpenMathErrorKind, List Symbol) -> % 
-  ++ omError(k,l) creates an instance of OpenMathError.
- == add
-  Rep := Record(err:OpenMathErrorKind, info:List Symbol)
-
-  import List String
-
-  coerce(e:%):OutputForm ==
-    OMParseError? e.err => message "Error parsing OpenMath object"
-    infoSize := #(e.info)
-    OMUnknownCD? e.err => 
---      not one? infoSize => error "Malformed info list in OMUnknownCD"
-      not (infoSize = 1) => error "Malformed info list in OMUnknownCD"
-      message concat("Cannot handle CD ",string first e.info)
-    OMUnknownSymbol? e.err =>
-      not 2=infoSize => error "Malformed info list in OMUnknownSymbol"
-      message concat ["Cannot handle Symbol ",
-                      string e.info.2, " from CD ", string e.info.1]
-    OMReadError? e.err =>
-      message "OpenMath read error"
-    error "Malformed OpenMath Error"
-
-  omError(e:OpenMathErrorKind,i:List Symbol):% == [e,i]$Rep
-
-  errorKind(e:%):OpenMathErrorKind == e.err
-  errorInfo(e:%):List Symbol == e.info
-
-@
-\section{License}
-<<license>>=
---Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
---All rights reserved.
---
---Redistribution and use in source and binary forms, with or without
---modification, are permitted provided that the following conditions are
---met:
---
---    - Redistributions of source code must retain the above copyright
---      notice, this list of conditions and the following disclaimer.
---
---    - Redistributions in binary form must reproduce the above copyright
---      notice, this list of conditions and the following disclaimer in
---      the documentation and/or other materials provided with the
---      distribution.
---
---    - Neither the name of The Numerical ALgorithms Group Ltd. nor the
---      names of its contributors may be used to endorse or promote products
---      derived from this software without specific prior written permission.
---
---THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
---IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
---TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
---PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
---OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
---EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
---PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
---PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
---LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
---NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
---SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-@
-<<*>>=
-<<license>>
-
-<<domain OMERRK OpenMathErrorKind>>
-<<domain OMERR OpenMathError>>
-@
-\eject
-\begin{thebibliography}{99}
-\bibitem{1} nothing
-\end{thebibliography}
-\end{document}
diff --git a/src/algebra/op.spad.pamphlet b/src/algebra/op.spad.pamphlet
index cd18222..ed28ee3 100644
--- a/src/algebra/op.spad.pamphlet
+++ b/src/algebra/op.spad.pamphlet
@@ -9,491 +9,6 @@
 \eject
 \tableofcontents
 \eject
-\section{domain BOP BasicOperator}
-<<BasicOperator.input>>=
--- op.spad.pamphlet BasicOperator.input
-)spool BasicOperator.output
-)set message test on
-)set message auto off
-)clear all
---S 1 of 18
-y := operator 'y
---R 
---R
---R   (1)  y
---R                                                          Type: BasicOperator
---E 1
-
---S 2 of 18
-deq := D(y x, x, 2) + D(y x, x) + y x = 0
---R 
---R
---R         ,,       ,
---R   (2)  y  (x) + y (x) + y(x)= 0
---R
---R                                            Type: Equation Expression Integer
---E 2
-
---S 3 of 18
-solve(deq, y, x)
---R 
---R
---R                                             x     x
---R                                     +-+   - -   - -      +-+
---R                                   x\|3      2     2    x\|3
---R   (3)  [particular= 0,basis= [cos(-----)%e   ,%e   sin(-----)]]
---R                                     2                    2
---RType: Union(Record(particular: Expression Integer,basis: List Expression Integer),...)
---E 3
-
---S 4 of 18
-nary? y
---R 
---R
---R   (4)  true
---R                                                                Type: Boolean
---E 4
-
---S 5 of 18
-unary? y
---R 
---R
---R   (5)  false
---R                                                                Type: Boolean
---E 5
-
---S 6 of 18
-opOne := operator('opOne, 1)
---R 
---R
---R   (6)  opOne
---R                                                          Type: BasicOperator
---E 6
-
---S 7 of 18
-nary? opOne
---R 
---R
---R   (7)  false
---R                                                                Type: Boolean
---E 7
-
---S 8 of 18
-unary? opOne
---R 
---R
---R   (8)  true
---R                                                                Type: Boolean
---E 8
-
---S 9 of 18
-arity opOne
---R 
---R
---R   (9)  1
---R                                          Type: Union(NonNegativeInteger,...)
---E 9
-
---S 10 of 18
-name opOne
---R 
---R
---R   (10)  opOne
---R                                                                 Type: Symbol
---E 10
-
---S 11 of 18
-is?(opOne, 'z2)
---R 
---R
---R   (11)  false
---R                                                                Type: Boolean
---E 11
-
---S 12 of 18
-is?(opOne, "opOne")
---R 
---R
---R   (12)  true
---R                                                                Type: Boolean
---E 12
-
---S 13 of 18
-properties y
---R 
---R
---R   (13)  table()
---R                                           Type: AssociationList(String,None)
---E 13
-
---S 14 of 18
-setProperty(y, "use", "unknown function" :: None )
---R 
---R
---R   (14)  y
---R                                                          Type: BasicOperator
---E 14
-
---S 15 of 18
-properties y
---R 
---R
---R   (15)  table("use"= NONE)
---R                                           Type: AssociationList(String,None)
---E 15
-
---S 16 of 18
-property(y, "use") :: None pretend String
---R 
---R
---R   (16)  "unknown function"
---R                                                                 Type: String
---E 16
-
---S 17 of 18
-deleteProperty!(y, "use")
---R 
---R
---R   (17)  y
---R                                                          Type: BasicOperator
---E 17
-
---S 18 of 18
-properties y
---R 
---R
---R   (18)  table()
---R                                           Type: AssociationList(String,None)
---E 18
-)spool
-)lisp (bye)
-@
-<<BasicOperator.help>>=
-====================================================================
-BasicOperator examples
-====================================================================
-
-A basic operator is an object that can be symbolically applied to a
-list of arguments from a set, the result being a kernel over that set
-or an expression.  
-
-You create an object of type BasicOperator by using the operator
-operation.  This first form of this operation has one argument and it
-must be a symbol.  The symbol should be quoted in case the name has
-been used as an identifier to which a value has been assigned.
-
-A frequent application of BasicOperator is the creation of an operator
-to represent the unknown function when solving a differential equation.
-
-Let y be the unknown function in terms of x.
-
-  y := operator 'y
-   y 
-                      Type: BasicOperator
-
-This is how you enter the equation y'' + y' + y = 0.
-
-  deq := D(y x, x, 2) + D(y x, x) + y x = 0
-    ,,       ,
-   y  (x) + y (x) + y(x) = 0
-                      Type: Equation Expression Integer
-
-To solve the above equation, enter this.
-
-  solve(deq, y, x)
-                                        x     x
-                                +-+   - -   - -      +-+
-                              x\|3      2     2    x\|3
-   [particular= 0,basis= [cos(-----)%e   ,%e   sin(-----)]]
-                                2                    2
-                      Type: Union(Record(particular: Expression Integer,
-                                  basis: List Expression Integer),...)
-
-Use the single argument form of BasicOperator (as above) when you
-intend to use the operator to create functional expressions with an
-arbitrary number of arguments
-
-Nary means an arbitrary number of arguments can be used in the
-functional expressions.
-
-  nary? y
-   true
-                      Type: Boolean
-
-  unary? y
-   false
-                      Type: Boolean
-
-Use the two-argument form when you want to restrict the number of
-arguments in the functional expressions created with the operator.
-
-This operator can only be used to create functional expressions
-with one argument.
-
-  opOne := operator('opOne, 1)
-   opOne 
-                      Type: BasicOperator
-
-  nary? opOne
-   false
-                      Type: Boolean
-
-  unary? opOne
-   true
-                      Type: Boolean
-
-Use arity to learn the number of arguments that can be used.  It
-returns "false" if the operator is nary.
-
-  arity opOne
-   1
-                      Type: Union(NonNegativeInteger,...)
-
-Use name to learn the name of an operator.
-
-  name opOne
-   opOne 
-                      Type: Symbol
-
-Use is? to learn if an operator has a particular name.
-
-  is?(opOne, 'z2)
-   false
-                      Type: Boolean
-
-You can also use a string as the name to be tested against.
-
-  is?(opOne, "opOne")
-   true
-                      Type: Boolean
-
-You can attached named properties to an operator.  These are rarely
-used at the top-level of the Axiom interactive environment but are
-used with Axiom library source code.
-
-By default, an operator has no properties.
-
-  properties y
-   table() 
-                      Type: AssociationList(String,None)
-
-The interface for setting and getting properties is somewhat awkward
-because the property values are stored as values of type None.
-
-Attach a property by using setProperty.
-
-  setProperty(y, "use", "unknown function" :: None )
-   y 
-                      Type: BasicOperator
-
-  properties y
-   table("use"=NONE)
-                      Type: AssociationList(String,None)
-
-We know the property value has type String.
-
-  property(y, "use") :: None pretend String
-   "unknown function"
-                      Type: String
-
-Use deleteProperty! to destructively remove a property.
-
- deleteProperty!(y, "use")
-  y 
-                      Type: BasicOperator
-
-  properties y
-   table() 
-                      Type: AssociationList(String,None)
-
-
-See Also
-o )help Expression
-o )help Kernel
-o )show BasicOperator
-o $AXIOM/doc/src/algebra/op.spad.dvi
-
-@
-<<domain BOP BasicOperator>>=
-)abbrev domain BOP BasicOperator
-++ Basic system operators
-++ Author: Manuel Bronstein
-++ Date Created: 22 March 1988
-++ Date Last Updated: 11 October 1993
-++ Description:
-++   A basic operator is an object that can be applied to a list of
-++   arguments from a set, the result being a kernel over that set.
-++ Keywords: operator, kernel.
-BasicOperator(): Exports == Implementation where
-  O   ==> OutputForm
-  P   ==> AssociationList(String, None)
-  L   ==> List Record(key:String, entry:None)
-  SEX ==> InputForm
--- some internal properties
-  LESS?   ==> "%less?"
-  EQUAL?  ==> "%equal?"
-  WEIGHT  ==> "%weight"
-  DISPLAY ==> "%display"
-  SEXPR   ==> "%input"
-
-  Exports ==> OrderedSet with
-    name      : $ -> Symbol
-      ++ name(op) returns the name of op.
-    properties: $ -> P
-      ++ properties(op) returns the list of all the properties
-      ++ currently attached to op.
-    copy      : $ -> $
-      ++ copy(op) returns a copy of op.
-    operator  : Symbol -> $
-      ++ operator(f) makes f into an operator with arbitrary arity.
-    operator  : (Symbol, NonNegativeInteger) -> $
-      ++ operator(f, n) makes f into an n-ary operator.
-    arity     : $ -> Union(NonNegativeInteger, "failed")
-      ++ arity(op) returns n if op is n-ary, and
-      ++ "failed" if op has arbitrary arity.
-    nullary?  : $ -> Boolean
-      ++ nullary?(op) tests if op is nullary.
-    unary?    : $ -> Boolean
-      ++ unary?(op) tests if op is unary.
-    nary?     : $ -> Boolean
-      ++ nary?(op) tests if op has arbitrary arity.
-    weight    : $ -> NonNegativeInteger
-      ++ weight(op) returns the weight attached to op.
-    weight    : ($, NonNegativeInteger) -> $
-      ++ weight(op, n) attaches the weight n to op.
-    equality   : ($, ($, $) -> Boolean) -> $
-      ++ equality(op, foo?) attaches foo? as the "%equal?" property
-      ++ to op. If op1 and op2 have the same name, and one of them
-      ++ has an "%equal?" property f, then \spad{f(op1, op2)} is called to
-      ++ decide whether op1 and op2 should be considered equal.
-    comparison : ($, ($, $) -> Boolean) -> $
-      ++ comparison(op, foo?) attaches foo? as the "%less?" property
-      ++ to op. If op1 and op2 have the same name, and one of them
-      ++ has a "%less?" property f, then \spad{f(op1, op2)} is called to
-      ++ decide whether \spad{op1 < op2}.
-    display    : $ -> Union(List O -> O, "failed")
-      ++ display(op) returns the "%display" property of op if
-      ++ it has one attached, and "failed" otherwise.
-    display    : ($, List O -> O)      -> $
-      ++ display(op, foo) attaches foo as the "%display" property
-      ++ of op. If op has a "%display" property f, then \spad{op(a1,...,an)}
-      ++ gets converted to OutputForm as \spad{f(a1,...,an)}.
-    display    : ($, O -> O)           -> $
-      ++ display(op, foo) attaches foo as the "%display" property
-      ++ of op. If op has a "%display" property f, then \spad{op(a)}
-      ++ gets converted to OutputForm as \spad{f(a)}.
-      ++ Argument op must be unary.
-    input      : ($, List SEX -> SEX)  -> $
-      ++ input(op, foo) attaches foo as the "%input" property
-      ++ of op. If op has a "%input" property f, then \spad{op(a1,...,an)}
-      ++ gets converted to InputForm as \spad{f(a1,...,an)}.
-    input      : $ -> Union(List SEX -> SEX, "failed")
-      ++ input(op) returns the "%input" property of op if
-      ++ it has one attached, "failed" otherwise.
-    is?        : ($, Symbol) -> Boolean
-      ++ is?(op, s) tests if the name of op is s.
-    has?       : ($, String) -> Boolean
-      ++ has?(op, s) tests if property s is attached to op.
-    assert     : ($, String) -> $
-      ++ assert(op, s) attaches property s to op.
-      ++ Argument op is modified "in place", i.e. no copy is made.
-    deleteProperty_!: ($, String) -> $
-      ++ deleteProperty!(op, s) unattaches property s from op.
-      ++ Argument op is modified "in place", i.e. no copy is made.
-    property      : ($, String) -> Union(None, "failed")
-      ++ property(op, s) returns the value of property s if
-      ++ it is attached to op, and "failed" otherwise.
-    setProperty   : ($, String, None) -> $
-      ++ setProperty(op, s, v) attaches property s to op,
-      ++ and sets its value to v.
-      ++ Argument op is modified "in place", i.e. no copy is made.
-    setProperties : ($, P) -> $
-      ++ setProperties(op, l) sets the property list of op to l.
-      ++ Argument op is modified "in place", i.e. no copy is made.
-
-  Implementation ==> add
-    -- if narg < 0 then the operator has variable arity.
-    Rep := Record(opname:Symbol, narg:SingleInteger, props:P)
-
-    oper: (Symbol, SingleInteger, P) -> $
-
-    is?(op, s)           == name(op) = s
-    name op              == op.opname
-    properties op        == op.props
-    setProperties(op, l) == (op.props := l; op)
-    operator s           == oper(s, -1::SingleInteger, table())
-    operator(s, n)       == oper(s, n::Integer::SingleInteger, table())
-    property(op, name)   == search(name, op.props)
-    assert(op, s)        == setProperty(op, s, NIL$Lisp)
-    has?(op, name)       == key?(name, op.props)
-    oper(se, n, prop)    == [se, n, prop]
-    weight(op, n)        == setProperty(op, WEIGHT, n pretend None)
-    nullary? op          == zero?(op.narg)
---    unary? op            == one?(op.narg)
-    unary? op            == ((op.narg) = 1)
-    nary? op             == negative?(op.narg)
-    equality(op, func)   == setProperty(op, EQUAL?, func pretend None)
-    comparison(op, func) == setProperty(op, LESS?, func pretend None)
-    display(op:$, f:O -> O)        == display(op, f first #1)
-    deleteProperty_!(op, name)     == (remove_!(name, properties op); op)
-    setProperty(op, name, valu)    == (op.props.name := valu; op)
-    coerce(op:$):OutputForm        == name(op)::OutputForm
-    input(op:$, f:List SEX -> SEX) == setProperty(op, SEXPR, f pretend None)
-    display(op:$, f:List O -> O)   == setProperty(op, DISPLAY, f pretend None)
-
-    display op ==
-      (u := property(op, DISPLAY)) case "failed" => "failed"
-      (u::None) pretend (List O -> O)
-
-    input op ==
-      (u := property(op, SEXPR)) case "failed" => "failed"
-      (u::None) pretend (List SEX -> SEX)
-
-    arity op ==
-      negative?(n := op.narg) => "failed"
-      convert(n)@Integer :: NonNegativeInteger
-
-    copy op ==
-      oper(name op, op.narg,
-          table([[r.key, r.entry] for r in entries(properties op)@L]$L))
-
--- property EQUAL? contains a function f: (BOP, BOP) -> Boolean
--- such that f(o1, o2) is true iff o1 = o2
-    op1 = op2 ==
-      (EQ$Lisp)(op1, op2) => true
-      name(op1) ^= name(op2) => false
-      op1.narg ^= op2.narg => false
-      brace(keys properties op1)^=$Set(String) _
-                     brace(keys properties op2) => false
-      (func := property(op1, EQUAL?)) case None =>
-                   ((func::None) pretend (($, $) -> Boolean)) (op1, op2)
-      true
-
--- property WEIGHT allows one to change the ordering around
--- by default, every operator has weigth 1
-    weight op ==
-      (w := property(op, WEIGHT)) case "failed" => 1
-      (w::None) pretend NonNegativeInteger
-
--- property LESS? contains a function f: (BOP, BOP) -> Boolean
--- such that f(o1, o2) is true iff o1 < o2
-    op1 < op2 ==
-      (w1 := weight op1) ^= (w2 := weight op2) => w1 < w2
-      op1.narg ^= op2.narg => op1.narg < op2.narg
-      name(op1) ^= name(op2) => name(op1) < name(op2)
-      n1 := #(k1 := brace(keys(properties op1))$Set(String))
-      n2 := #(k2 := brace(keys(properties op2))$Set(String))
-      n1 ^= n2 => n1 < n2
-      not zero?(n1 := #(d1 := difference(k1, k2))) =>
-        n1 ^= (n2 := #(d2 := difference(k2, k1))) => n1 < n2
-        inspect(d1) < inspect(d2)
-      (func := property(op1, LESS?)) case None =>
-                   ((func::None) pretend (($, $) -> Boolean)) (op1, op2)
-      (func := property(op1, EQUAL?)) case None =>
-              not(((func::None) pretend (($, $) -> Boolean)) (op1, op2))
-      false
-
-@
 \section{package BOP1 BasicOperatorFunctions1}
 <<package BOP1 BasicOperatorFunctions1>>=
 )abbrev package BOP1 BasicOperatorFunctions1
@@ -837,7 +352,6 @@ CommonOperators(): Exports == Implementation where
 --
 --   OP  kl  expr function
 
-<<domain BOP BasicOperator>>
 <<package BOP1 BasicOperatorFunctions1>>
 <<package COMMONOP CommonOperators>>
 @
diff --git a/src/algebra/opalg.spad.pamphlet b/src/algebra/opalg.spad.pamphlet
deleted file mode 100644
index d9ffc6d..0000000
--- a/src/algebra/opalg.spad.pamphlet
+++ /dev/null
@@ -1,680 +0,0 @@
-\documentclass{article}
-\usepackage{axiom}
-\begin{document}
-\title{\$SPAD/src/algebra opalg.spad}
-\author{Manuel Bronstein}
-\maketitle
-\begin{abstract}
-\end{abstract}
-\eject
-\tableofcontents
-\eject
-\section{domain MODOP ModuleOperator}
-<<domain MODOP ModuleOperator>>=
-)abbrev domain MODOP ModuleOperator
-++ Author: Manuel Bronstein
-++ Date Created: 15 May 1990
-++ Date Last Updated: 17 June 1993
-++ Description:
-++ Algebra of ADDITIVE operators on a module.
-ModuleOperator(R: Ring, M:LeftModule(R)): Exports == Implementation where
-  O    ==> OutputForm
-  OP   ==> BasicOperator
-  FG   ==> FreeGroup OP
-  RM   ==> Record(coef:R, monom:FG)
-  TERM ==> List RM
-  FAB  ==> FreeAbelianGroup TERM
-  OPADJ   ==> "%opAdjoint"
-  OPEVAL  ==> "%opEval"
-  INVEVAL ==> "%invEval"
-
-  Exports ==> Join(Ring, RetractableTo R, RetractableTo OP,
-                   Eltable(M, M)) with
-    if R has CharacteristicZero then CharacteristicZero
-    if R has CharacteristicNonZero then CharacteristicNonZero
-    if R has CommutativeRing then
-      Algebra(R)
-      adjoint: $ -> $
-        ++ adjoint(op) returns the adjoint of the operator \spad{op}.
-      adjoint: ($, $) -> $
-        ++ adjoint(op1, op2) sets the adjoint of op1 to be op2.
-        ++ op1 must be a basic operator
-      conjug  : R -> R
-        ++ conjug(x)should be local but conditional
-    evaluate: ($, M -> M) -> $
-      ++ evaluate(f, u +-> g u) attaches the map g to f.
-      ++ f must be a basic operator
-      ++ g MUST be additive, i.e. \spad{g(a + b) = g(a) + g(b)} for
-      ++ any \spad{a}, \spad{b} in M.
-      ++ This implies that \spad{g(n a) = n g(a)} for
-      ++ any \spad{a} in M and integer \spad{n > 0}.
-    evaluateInverse: ($, M -> M) -> $
-	++ evaluateInverse(x,f) \undocumented
-    "**": (OP, Integer) -> $
-	++ op**n \undocumented
-    "**": ($, Integer) -> $
-	++ op**n \undocumented
-    opeval  : (OP, M) -> M
-      ++ opeval should be local but conditional
-    makeop   : (R, FG) -> $
-      ++ makeop should be local but conditional
-
-  Implementation ==> FAB add
-    import NoneFunctions1($)
-    import BasicOperatorFunctions1(M)
-
-    Rep := FAB
-
-    inv      : TERM -> $
-    termeval : (TERM, M) -> M
-    rmeval   : (RM, M) -> M
-    monomeval: (FG, M) -> M
-    opInvEval: (OP, M) -> M
-    mkop     : (R, FG) -> $
-    termprod0: (Integer, TERM, TERM) -> $
-    termprod : (Integer, TERM, TERM) -> TERM
-    termcopy : TERM -> TERM
-    trm2O    : (Integer, TERM) -> O
-    term2O   : TERM -> O
-    rm2O     : (R, FG) -> O
-    nocopy   : OP -> $
-
-    1                   == makeop(1, 1)
-    coerce(n:Integer):$ == n::R::$
-    coerce(r:R):$       == (zero? r => 0; makeop(r, 1))
-    coerce(op:OP):$     == nocopy copy op
-    nocopy(op:OP):$     == makeop(1, op::FG)
-    elt(x:$, r:M)       == +/[t.exp * termeval(t.gen, r) for t in terms x]
-    rmeval(t, r)        == t.coef * monomeval(t.monom, r)
-    termcopy t          == [[rm.coef, rm.monom] for rm in t]
-    characteristic()    == characteristic()$R
-    mkop(r, fg)         == [[r, fg]$RM]$TERM :: $
-    evaluate(f, g)   == nocopy setProperty(retract(f)@OP,OPEVAL,g pretend None)
-
-    if R has OrderedSet then
-      makeop(r, fg) == (r >= 0 => mkop(r, fg); - mkop(-r, fg))
-    else makeop(r, fg) == mkop(r, fg)
-
-    inv(t:TERM):$ ==
-      empty? t => 1
-      c := first(t).coef
-      m := first(t).monom
-      inv(rest t) * makeop(1, inv m) * (recip(c)::R::$)
-
-    x:$ ** i:Integer ==
-      i = 0 => 1
-      i > 0 => expt(x,i pretend PositiveInteger)$RepeatedSquaring($)
-      (inv(retract(x)@TERM)) ** (-i)
-
-    evaluateInverse(f, g) ==
-      nocopy setProperty(retract(f)@OP, INVEVAL, g pretend None)
-
-    coerce(x:$):O ==
-      zero? x => (0$R)::O
-      reduce(_+, [trm2O(t.exp, t.gen) for t in terms x])$List(O)
-
-    trm2O(c, t) ==
---      one? c => term2O t
-      (c = 1) => term2O t
-      c = -1 => - term2O t
-      c::O * term2O t
-
-    term2O t ==
-      reduce(_*, [rm2O(rm.coef, rm.monom) for rm in t])$List(O)
-
-    rm2O(c, m) ==
---      one? c => m::O
-      (c = 1) => m::O
---      one? m => c::O
-      (m = 1) => c::O
-      c::O * m::O
-
-    x:$ * y:$ ==
-      +/[ +/[termprod0(t.exp * s.exp, t.gen, s.gen) for s in terms y]
-          for t in terms x]
-
-    termprod0(n, x, y) ==
-      n >= 0 => termprod(n, x, y)::$
-      - (termprod(-n, x, y)::$)
-
-    termprod(n, x, y) ==
-      lc := first(xx := termcopy x)
-      lc.coef := n * lc.coef
-      rm := last xx
---      one?(first(y).coef) =>
-      ((first(y).coef) = 1) =>
-        rm.monom := rm.monom * first(y).monom
-        concat_!(xx, termcopy rest y)
---      one?(rm.monom) =>
-      ((rm.monom) = 1) =>
-        rm.coef := rm.coef * first(y).coef
-        rm.monom := first(y).monom
-        concat_!(xx, termcopy rest y)
-      concat_!(xx, termcopy y)
-
-    if M has ExpressionSpace then
-      opeval(op, r) ==
-        (func := property(op, OPEVAL)) case "failed" => kernel(op, r)
-        ((func::None) pretend (M -> M)) r
-
-    else
-      opeval(op, r) ==
-        (func := property(op, OPEVAL)) case "failed" =>
-          error "eval: operator has no evaluation function"
-        ((func::None) pretend (M -> M)) r
-
-    opInvEval(op, r) ==
-      (func := property(op, INVEVAL)) case "failed" =>
-         error "eval: operator has no inverse evaluation function"
-      ((func::None) pretend (M -> M)) r
-
-    termeval(t, r)  ==
-      for rm in reverse t repeat r := rmeval(rm, r)
-      r
-
-    monomeval(m, r) ==
-      for rec in reverse_! factors m repeat
-        e := rec.exp
-        g := rec.gen
-        e > 0 =>
-          for i in 1..e repeat r := opeval(g, r)
-        e < 0 =>
-          for i in 1..(-e) repeat r := opInvEval(g, r)
-      r
-
-    recip x ==
-      (r := retractIfCan(x)@Union(R, "failed")) case "failed" => "failed"
-      (r1 := recip(r::R)) case "failed" => "failed"
-      r1::R::$
-
-    retractIfCan(x:$):Union(R, "failed") ==
-      (r:= retractIfCan(x)@Union(TERM,"failed")) case "failed" => "failed"
-      empty?(t := r::TERM) => 0$R
-      empty? rest t =>
-        rm := first t
---        one?(rm.monom) => rm.coef
-        (rm.monom = 1) => rm.coef
-        "failed"
-      "failed"
-
-    retractIfCan(x:$):Union(OP, "failed") ==
-      (r:= retractIfCan(x)@Union(TERM,"failed")) case "failed" => "failed"
-      empty?(t := r::TERM) => "failed"
-      empty? rest t =>
-        rm := first t
---        one?(rm.coef) => retractIfCan(rm.monom)
-        (rm.coef = 1) => retractIfCan(rm.monom)
-        "failed"
-      "failed"
-
-    if R has CommutativeRing then
-      termadj  : TERM -> $
-      rmadj    : RM -> $
-      monomadj : FG -> $
-      opadj    : OP -> $
-
-      r:R * x:$        == r::$ * x
-      x:$ * r:R        == x * (r::$)
-      adjoint x        == +/[t.exp * termadj(t.gen) for t in terms x]
-      rmadj t          == conjug(t.coef) * monomadj(t.monom)
-      adjoint(op, adj) == nocopy setProperty(retract(op)@OP, OPADJ, adj::None)
-
-      termadj t ==
-        ans:$ := 1
-        for rm in t repeat ans := rmadj(rm) * ans
-        ans
-
-      monomadj m ==
-        ans:$ := 1
-        for rec in factors m repeat ans := (opadj(rec.gen) ** rec.exp) * ans
-        ans
-
-      opadj op ==
-        (adj := property(op, OPADJ)) case "failed" =>
-           error "adjoint: operator does not have a defined adjoint"
-        (adj::None) pretend $
-
-      if R has conjugate:R -> R then conjug r == conjugate r else conjug r == r
-
-@
-\section{domain OP Operator}
-<<Operator.input>>=
--- opalg.spad.pamphlet Operator.input
-)spool Operator.output
-)set message test on
-)set message auto off
-)clear all
---S 1 of 21
-R := SQMATRIX(2, INT)
---R 
---R
---R   (1)  SquareMatrix(2,Integer)
---R                                                                 Type: Domain
---E 1
-
---S 2 of 21
-t := operator("tilde") :: OP(R)
---R 
---R
---R   (2)  tilde
---R                                       Type: Operator SquareMatrix(2,Integer)
---E 2
-
---S 3 of 21
-)set expose add constructor Operator
---R 
---I   Operator is now explicitly exposed in frame frame0 
---E 3
-
---S 4 of 21
-evaluate(t, m +-> transpose m)
---R 
---R
---R   (3)  tilde
---R                                       Type: Operator SquareMatrix(2,Integer)
---E 4
-
---S 5 of 21
-s : R := matrix [ [0, 1], [1, 0] ]
---R 
---R
---R        +0  1+
---R   (4)  |    |
---R        +1  0+
---R                                                Type: SquareMatrix(2,Integer)
---E 5
-
---S 6 of 21
-rho := t * s
---R 
---R
---R             +0  1+
---R   (5)  tilde|    |
---R             +1  0+
---R                                       Type: Operator SquareMatrix(2,Integer)
---E 6
-
---S 7 of 21
-z := rho**4 - 1
---R 
---R
---R                   +0  1+     +0  1+     +0  1+     +0  1+
---R   (6)  - 1 + tilde|    |tilde|    |tilde|    |tilde|    |
---R                   +1  0+     +1  0+     +1  0+     +1  0+
---R                                       Type: Operator SquareMatrix(2,Integer)
---E 7
-
---S 8 of 21
-m:R := matrix [ [1, 2], [3, 4] ]
---R 
---R
---R        +1  2+
---R   (7)  |    |
---R        +3  4+
---R                                                Type: SquareMatrix(2,Integer)
---E 8
-
---S 9 of 21
-z m
---R 
---R
---R        +0  0+
---R   (8)  |    |
---R        +0  0+
---R                                                Type: SquareMatrix(2,Integer)
---E 9
-
---S 10 of 21
-rho m
---R 
---R
---R        +3  1+
---R   (9)  |    |
---R        +4  2+
---R                                                Type: SquareMatrix(2,Integer)
---E 10
-
---S 11 of 21
-rho rho m
---R 
---R
---R         +4  3+
---R   (10)  |    |
---R         +2  1+
---R                                                Type: SquareMatrix(2,Integer)
---E 11
-
---S 12 of 21
-(rho^3) m
---R 
---R
---R         +2  4+
---R   (11)  |    |
---R         +1  3+
---R                                                Type: SquareMatrix(2,Integer)
---E 12
-
---S 13 of 21
-b := t * s - s * t
---R 
---R
---R           +0  1+             +0  1+
---R   (12)  - |    |tilde + tilde|    |
---R           +1  0+             +1  0+
---R                                       Type: Operator SquareMatrix(2,Integer)
---E 13
-
---S 14 of 21
-b m
---R 
---R
---R         +1  - 3+
---R   (13)  |      |
---R         +3  - 1+
---R                                                Type: SquareMatrix(2,Integer)
---E 14
-
---S 15 of 21
-L n ==
-  n = 0 => 1
-  n = 1 => x
-  (2*n-1)/n * x * L(n-1) - (n-1)/n * L(n-2)
---R 
---R                                                                   Type: Void
---E 15
-
---S 16 of 21
-dx := operator("D") :: OP(POLY FRAC INT)
---R 
---R
---R   (15)  D
---R                                   Type: Operator Polynomial Fraction Integer
---E 16
-
---S 17 of 21
-evaluate(dx, p +-> D(p, 'x))
---R 
---R
---R   (16)  D
---R                                   Type: Operator Polynomial Fraction Integer
---E 17
-
---S 18 of 21
-E n == (1 - x**2) * dx**2 - 2 * x * dx + n*(n+1)
---R 
---R                                                                   Type: Void
---E 18
-
---S 19 of 21
-L 15
---R 
---R   Compiling function L with type Integer -> Polynomial Fraction 
---R      Integer 
---R   Compiling function L as a recurrence relation.
---R
---R   (18)
---R     9694845  15   35102025  13   50702925  11   37182145  9   14549535  7
---R     ------- x   - -------- x   + -------- x   - -------- x  + -------- x
---R       2048          2048           2048           2048          2048
---R   + 
---R       2909907  5   255255  3   6435
---R     - ------- x  + ------ x  - ---- x
---R         2048        2048       2048
---R                                            Type: Polynomial Fraction Integer
---E 19
-
---S 20 of 21
-E 15
---R 
---R   Compiling function E with type PositiveInteger -> Operator 
---R      Polynomial Fraction Integer 
---R
---R                        2      2
---R   (19)  240 - 2x D - (x  - 1)D
---R                                   Type: Operator Polynomial Fraction Integer
---E 20
-
---S 21 of 21
-(E 15)(L 15)
---R 
---R
---R   (20)  0
---R                                            Type: Polynomial Fraction Integer
---E 21
-)spool
-)lisp (bye)
-@
-<<Operator.help>>=
-====================================================================
-Operator examples
-====================================================================
-
-Given any ring R, the ring of the Integer-linear operators over R is
-called Operator(R).  To create an operator over R, first create a
-basic operator using the operation operator, and then convert it to
-Operator(R) for the R you want.
-
-We choose R to be the two by two matrices over the integers.
-
-  R := SQMATRIX(2, INT)
-    SquareMatrix(2,Integer)
-                            Type: Domain
-
-Create the operator tilde on R.
-
-  t := operator("tilde") :: OP(R)
-    tilde
-                            Type: Operator SquareMatrix(2,Integer)
-
-Since Operator is unexposed we must either package-call operations
-from it, or expose it explicitly.  For convenience we will do the latter.
-
-Expose Operator.
-
-  )set expose add constructor Operator
-
-To attach an evaluation function (from R to R) to an operator over R,
-use evaluate(op, f) where op is an operator over R and f is a function
-R -> R.  This needs to be done only once when the operator is defined.
-Note that f must be Integer-linear (that is, f(ax+y) = a f(x) + f(y)
-for any integer a, and any x and y in R).
-
-We now attach the transpose map to the above operator t.
-
-  evaluate(t, m +-> transpose m)
-    tilde
-                       Type: Operator SquareMatrix(2,Integer)
-
-Operators can be manipulated formally as in any ring: + is the
-pointwise addition and * is composition.  Any element x of R can be
-converted to an operator op(x) over R, and the evaluation function of
-op(x) is left-multiplication by x.
-
-Multiplying on the left by this matrix swaps the two rows.
-
-  s : R := matrix [ [0, 1], [1, 0] ]
-        +0  1+
-        |    |
-        +1  0+
-                       Type: SquareMatrix(2,Integer)
-
-Can you guess what is the action of the following operator?
-
-  rho := t * s
-             +0  1+
-        tilde|    |
-             +1  0+
-                       Type: Operator SquareMatrix(2,Integer)
-
-Hint: applying rho four times gives the identity, so rho^4-1 should
-return 0 when applied to any two by two matrix.
-
-  z := rho**4 - 1
-                   +0  1+     +0  1+     +0  1+     +0  1+
-        - 1 + tilde|    |tilde|    |tilde|    |tilde|    |
-                   +1  0+     +1  0+     +1  0+     +1  0+
-                       Type: Operator SquareMatrix(2,Integer)
-
-Now check with this matrix.
-
-  m:R := matrix [ [1, 2], [3, 4] ]
-        +1  2+
-        |    |
-        +3  4+
-                       Type: SquareMatrix(2,Integer)
-
-  z m
-        +0  0+
-        |    |
-        +0  0+
-                       Type: SquareMatrix(2,Integer)
-
-As you have probably guessed by now, rho acts on matrices by rotating
-the elements clockwise.
-
-  rho m
-        +3  1+
-        |    |
-        +4  2+
-                       Type: SquareMatrix(2,Integer)
-
-  rho rho m
-         +4  3+
-         |    |
-         +2  1+
-                       Type: SquareMatrix(2,Integer)
-
-  (rho^3) m
-         +2  4+
-         |    |
-         +1  3+
-                       Type: SquareMatrix(2,Integer)
-
-Do the swapping of rows and transposition commute?  We can check by
-computing their bracket.
-
-  b := t * s - s * t
-           +0  1+             +0  1+
-         - |    |tilde + tilde|    |
-           +1  0+             +1  0+
-                       Type: Operator SquareMatrix(2,Integer)
-
-Now apply it to m.
-
-  b m
-         +1  - 3+
-         |      |
-         +3  - 1+
-                       Type: SquareMatrix(2,Integer)
- 
-Next we demonstrate how to define a differential operator on a polynomial ring.
-
-This is the recursive definition of the n-th Legendre polynomial.
-
-  L n ==
-    n = 0 => 1
-    n = 1 => x
-    (2*n-1)/n * x * L(n-1) - (n-1)/n * L(n-2)
-                        Type: Void
-
-Create the differential operator d/dx on polynomials in x over the
-rational numbers.
-
-  dx := operator("D") :: OP(POLY FRAC INT)
-     D
-                        Type: Operator Polynomial Fraction Integer
-
-Now attach the map to it.
-
-  evaluate(dx, p +-> D(p, 'x))
-    D
-                        Type: Operator Polynomial Fraction Integer
-
-This is the differential equation satisfied by the n-th Legendre polynomial.
-
-  E n == (1 - x**2) * dx**2 - 2 * x * dx + n*(n+1)
-                        Type: Void
-
-Now we verify this for n = 15.  Here is the polynomial.
-
-  L 15
-     9694845  15   35102025  13   50702925  11   37182145  9   14549535  7
-     ------- x   - -------- x   + -------- x   - -------- x  + -------- x
-       2048          2048           2048           2048          2048
-   + 
-       2909907  5   255255  3   6435
-     - ------- x  + ------ x  - ---- x
-         2048        2048       2048
-                        Type: Polynomial Fraction Integer
-
-Here is the operator.
-
-  E 15
-    240 - 2x D - (x  - 1)D
-                        Type: Operator Polynomial Fraction Integer
-
-Here is the evaluation.
-
-  (E 15)(L 15)
-    0
-                        Type: Polynomial Fraction Integer
-
-See Also:
-o )show Operator
-o $AXIOM/doc/src/algebra/opalg.spad.dvi
-
-@
-<<domain OP Operator>>=
-)abbrev domain OP Operator
-++ Author: Manuel Bronstein
-++ Date Created: 15 May 1990
-++ Date Last Updated: 12 February 1993
-++ Description:
-++ Algebra of ADDITIVE operators over a ring.
-Operator(R: Ring) == ModuleOperator(R,R)
-
-@
-\section{License}
-<<license>>=
---Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
---All rights reserved.
---
---Redistribution and use in source and binary forms, with or without
---modification, are permitted provided that the following conditions are
---met:
---
---    - Redistributions of source code must retain the above copyright
---      notice, this list of conditions and the following disclaimer.
---
---    - Redistributions in binary form must reproduce the above copyright
---      notice, this list of conditions and the following disclaimer in
---      the documentation and/or other materials provided with the
---      distribution.
---
---    - Neither the name of The Numerical ALgorithms Group Ltd. nor the
---      names of its contributors may be used to endorse or promote products
---      derived from this software without specific prior written permission.
---
---THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
---IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
---TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
---PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
---OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
---EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
---PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
---PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
---LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
---NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
---SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-@
-<<*>>=
-<<license>>
-
-<<domain MODOP ModuleOperator>>
-<<domain OP Operator>>
-@
-\eject
-\begin{thebibliography}{99}
-\bibitem{1} nothing
-\end{thebibliography}
-\end{document}
diff --git a/src/algebra/ore.spad.pamphlet b/src/algebra/ore.spad.pamphlet
index 8e07b6b..8c5bc5c 100644
--- a/src/algebra/ore.spad.pamphlet
+++ b/src/algebra/ore.spad.pamphlet
@@ -34,61 +34,6 @@ ApplyUnivariateSkewPolynomial(R:Ring, M: LeftModule R,
         w
 
 @
-\section{domain AUTOMOR Automorphism}
-<<domain AUTOMOR Automorphism>>=
-)abbrev domain AUTOMOR Automorphism
-++ Author: Manuel Bronstein
-++ Date Created: 31 January 1994
-++ Date Last Updated: 31 January 1994
-++ References:
-++ Description:
-++       Automorphism R is the multiplicative group of automorphisms of R.
--- In fact, non-invertible endomorphism are allowed as partial functions.
--- This domain is noncanonical in that f*f^{-1} will be the identity
--- function but won't be equal to 1.
-Automorphism(R:Ring): Join(Group, Eltable(R, R)) with
-      morphism: (R -> R) -> %
-        ++ morphism(f) returns the non-invertible morphism given by f.
-      morphism: (R -> R, R -> R) -> %
-        ++ morphism(f, g) returns the invertible morphism given by f, where
-        ++ g is the inverse of f..
-      morphism: ((R, Integer) -> R) -> %
-        ++ morphism(f) returns the morphism given by \spad{f^n(x) = f(x,n)}.
-   == add
-      err:   R -> R
-      ident: (R, Integer) -> R
-      iter:  (R -> R, NonNegativeInteger, R) -> R
-      iterat: (R -> R, R -> R, Integer, R) -> R
-      apply: (%, R, Integer) -> R
- 
-      Rep := ((R, Integer) -> R)
- 
-      1                               == ident
-      err r                           == error "Morphism is not invertible"
-      ident(r, n)                     == r
-      f = g                           == EQ(f, g)$Lisp
-      elt(f, r)                       == apply(f, r, 1)
-      inv f                           == apply(f, #1, - #2)
-      f ** n                          == apply(f, #1, n * #2)
-      coerce(f:%):OutputForm          == message("R -> R")
-      morphism(f:(R, Integer) -> R):% == f
-      morphism(f:R -> R):%            == morphism(f, err)
-      morphism(f, g)                  == iterat(f, g, #2, #1)
-      apply(f, r, n) == (g := f pretend ((R, Integer) -> R); g(r, n))
- 
-      iterat(f, g, n, r) ==
-          n < 0 => iter(g, (-n)::NonNegativeInteger, r)
-          iter(f, n::NonNegativeInteger, r)
- 
-      iter(f, n, r) ==
-          for i in 1..n repeat r := f r
-          r
- 
-      f * g ==
-        f = g => f**2
-        iterat(f g #1, (inv g)(inv f) #1, #2, #1)
-
-@
 \section{package OREPCTO UnivariateSkewPolynomialCategoryOps}
 <<package OREPCTO UnivariateSkewPolynomialCategoryOps>>=
 )abbrev package OREPCTO UnivariateSkewPolynomialCategoryOps
@@ -220,56 +165,6 @@ UnivariateSkewPolynomialCategoryOps(R, C): Exports == Implementation where
                 localRightDivide(a, b, sigma, inv leadingCoefficient b)
 
 @
-\section{domain ORESUP SparseUnivariateSkewPolynomial}
-<<domain ORESUP SparseUnivariateSkewPolynomial>>=
-)abbrev domain ORESUP SparseUnivariateSkewPolynomial
-++ Author: Manuel Bronstein
-++ Date Created: 19 October 1993
-++ Date Last Updated: 1 February 1994
-++ Description:
-++   This is the domain of sparse univariate skew polynomials over an Ore
-++   coefficient field.
-++   The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
-SparseUnivariateSkewPolynomial(R:Ring, sigma:Automorphism R, delta: R -> R):
- UnivariateSkewPolynomialCategory R with
-      outputForm: (%, OutputForm) -> OutputForm
-        ++ outputForm(p, x) returns the output form of p using x for the
-        ++ otherwise anonymous variable.
-   == SparseUnivariatePolynomial R add
-      import UnivariateSkewPolynomialCategoryOps(R, %)
- 
-      x:% * y:%      == times(x, y, sigma, delta)
-      apply(p, c, r) == apply(p, c, r, sigma, delta)
- 
-      if R has IntegralDomain then
-          monicLeftDivide(a, b)  == monicLeftDivide(a, b, sigma)
-          monicRightDivide(a, b) == monicRightDivide(a, b, sigma)
- 
-      if R has Field then
-          leftDivide(a, b)  == leftDivide(a, b, sigma)
-          rightDivide(a, b) == rightDivide(a, b, sigma)
-
-@
-\section{domain OREUP UnivariateSkewPolynomial}
-<<domain OREUP UnivariateSkewPolynomial>>=
-)abbrev domain OREUP UnivariateSkewPolynomial
-++ Author: Manuel Bronstein
-++ Date Created: 19 October 1993
-++ Date Last Updated: 1 February 1994
-++ Description:
-++   This is the domain of univariate skew polynomials over an Ore
-++   coefficient field in a named variable.
-++   The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
-UnivariateSkewPolynomial(x:Symbol, R:Ring, sigma:Automorphism R, delta: R -> R):
- UnivariateSkewPolynomialCategory R with
-   coerce: Variable x -> %
-     ++ coerce(x) returns x as a skew-polynomial.
-  == SparseUnivariateSkewPolynomial(R, sigma, delta) add
-     Rep := SparseUnivariateSkewPolynomial(R, sigma, delta)
-     coerce(v:Variable(x)):% == monomial(1, 1)
-     coerce(p:%):OutputForm  == outputForm(p, outputForm x)$Rep
-
-@
 \section{License}
 <<license>>=
 --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
@@ -307,10 +202,7 @@ UnivariateSkewPolynomial(x:Symbol, R:Ring, sigma:Automorphism R, delta: R -> R):
 <<license>>
  
 <<package APPLYORE ApplyUnivariateSkewPolynomial>>
-<<domain AUTOMOR Automorphism>>
 <<package OREPCTO UnivariateSkewPolynomialCategoryOps>>
-<<domain ORESUP SparseUnivariateSkewPolynomial>>
-<<domain OREUP UnivariateSkewPolynomial>>
 @
 \eject
 \begin{thebibliography}{99}
diff --git a/src/algebra/outform.spad.pamphlet b/src/algebra/outform.spad.pamphlet
index 16e6543..efea968 100644
--- a/src/algebra/outform.spad.pamphlet
+++ b/src/algebra/outform.spad.pamphlet
@@ -202,722 +202,6 @@ NumberFormats(): NFexports == NFimplementation where
             tot::PI
 
 @
-\section{domain OUTFORM OutputForm}
-<<domain OUTFORM OutputForm>>=
-)abbrev domain OUTFORM OutputForm
-++ Keywords: output, I/O, expression
-++ SMW March/88
-++ Description:
-++ This domain is used to create and manipulate mathematical expressions
-++ for output.  It is intended to provide an insulating layer between
-++ the expression rendering software (e.g.FORTRAN, TeX, or Script) and
-++ the output coercions in the various domains.
-
-OutputForm(): SetCategory with
-        --% Printing
-        print  : $ -> Void
-          ++ print(u) prints the form u.
-        message: String -> $
-          ++ message(s) creates an form with no string quotes
-          ++ from string s.
-        messagePrint: String -> Void
-          ++ messagePrint(s) prints s without string quotes. Note:
-          ++ \spad{messagePrint(s)} is equivalent to \spad{print message(s)}.
-        --% Creation of atomic forms
-        outputForm: Integer -> $
-          ++ outputForm(n) creates an form for integer n.
-        outputForm: Symbol  -> $
-          ++ outputForm(s) creates an form for symbol s.
-        outputForm: String  -> $
-          ++ outputForm(s) creates an form for string s.
-        outputForm: DoubleFloat  -> $
-          ++ outputForm(sf) creates an form for small float sf.
-        empty   : () -> $
-          ++ empty() creates an empty form.
-
-        --% Sizings
-        width: $ -> Integer
-          ++ width(f) returns the width of form f (an integer).
-        height: $ -> Integer
-          ++ height(f) returns the height of form f (an integer).
-        width: -> Integer
-          ++ width() returns the width of the display area (an integer).
-        height: -> Integer
-          ++ height() returns the height of the display area (an integer).
-        subHeight: $ -> Integer
-          ++ subHeight(f) returns the height of form f below the base line.
-        superHeight: $ -> Integer
-          ++ superHeight(f) returns the height of form f above the base line.
-         --% Space manipulations
-        hspace: Integer -> $  ++ hspace(n) creates white space of width n.
-        vspace: Integer -> $  ++ vspace(n) creates white space of height n.
-        rspace: (Integer,Integer) -> $
-          ++ rspace(n,m) creates rectangular white space, n wide by m high.
-        --% Area adjustments
-        left: ($,Integer) -> $
-          ++ left(f,n) left-justifies form f within space of width n.
-        right: ($,Integer) -> $
-          ++ right(f,n) right-justifies form f within space of width n.
-        center: ($,Integer) -> $
-          ++ center(f,n) centers form f within space of width n.
-        left: $ -> $
-          ++ left(f) left-justifies form f in total space.
-        right: $ -> $
-          ++ right(f) right-justifies form f in total space.
-        center:   $ -> $
-          ++ center(f) centers form f in total space.
-
-        --% Area manipulations
-        hconcat:  ($,$) -> $
-          ++ hconcat(f,g) horizontally concatenate forms f and g.
-        vconcat:  ($,$) -> $
-          ++ vconcat(f,g) vertically concatenates forms f and g.
-        hconcat:  List $ -> $
-          ++ hconcat(u) horizontally concatenates all forms in list u.
-        vconcat:  List $ -> $
-          ++ vconcat(u) vertically concatenates all forms in list u.
-
-        --% Application formers
-        prefix:  ($, List $) -> $
-          ++ prefix(f,l) creates a form depicting the n-ary prefix
-          ++ application of f to a tuple of arguments given by list l.
-        infix:   ($, List $) -> $
-          ++ infix(f,l) creates a form depicting the n-ary application
-          ++ of infix operation f to a tuple of arguments l.
-        infix:   ($, $, $) -> $
-          ++ infix(op, a, b) creates a form which prints as: a op b.
-        postfix: ($, $)    -> $
-          ++ postfix(op, a)  creates a form which prints as: a op.
-        infix?: $ -> Boolean
-          ++ infix?(op) returns true if op is an infix operator,
-          ++ and false otherwise.
-        elt:     ($, List $) -> $
-          ++ elt(op,l) creates a form for application of op
-          ++ to list of arguments l.
-
-        --% Special forms
-        string:  $ -> $
-          ++ string(f) creates f with string quotes.
-        label:   ($, $) -> $
-          ++ label(n,f) gives form f an equation label n.
-        box:     $ -> $
-          ++ box(f) encloses f in a box.
-        matrix:  List List $ -> $
-          ++ matrix(llf) makes llf (a list of lists of forms) into
-          ++ a form which displays as a matrix.
-        zag:     ($, $) -> $
-          ++ zag(f,g) creates a form for the continued fraction form for f over g.
-        root:    $ -> $
-          ++ root(f) creates a form for the square root of form f.
-        root:    ($, $) -> $
-          ++ root(f,n) creates a form for the nth root of form f.
-        over:    ($, $) -> $
-          ++ over(f,g) creates a form for the vertical fraction of f over g.
-        slash:   ($, $) -> $
-          ++ slash(f,g) creates a form for the horizontal fraction of f over g.
-        assign:  ($, $) -> $
-          ++ assign(f,g) creates a form for the assignment \spad{f := g}.
-        rarrow:  ($, $) -> $
-          ++ rarrow(f,g) creates a form for the mapping \spad{f -> g}.
-        differentiate: ($, NonNegativeInteger) -> $
-          ++ differentiate(f,n) creates a form for the nth derivative of f,
-          ++ e.g. \spad{f'}, \spad{f''}, \spad{f'''},
-          ++ "f super \spad{iv}".
-        binomial: ($, $) -> $
-          ++ binomial(n,m) creates a form for the binomial coefficient of n and m.
-
-        --% Scripts
-        sub:     ($, $) -> $
-          ++ sub(f,n) creates a form for f subscripted by n.
-        super:   ($, $) -> $
-          ++ super(f,n) creates a form for f superscripted by n.
-        presub:  ($, $) -> $
-          ++ presub(f,n) creates a form for f presubscripted by n.
-        presuper:($, $) -> $
-          ++ presuper(f,n) creates a form for f presuperscripted by n.
-        scripts: ($, List $) -> $
-            ++ \spad{scripts(f, [sub, super, presuper, presub])}
-            ++  creates a form for f with scripts on all 4 corners.
-        supersub:($, List $) -> $
-            ++ supersub(a,[sub1,super1,sub2,super2,...])
-            ++ creates a form with each subscript aligned
-            ++ under each superscript.
-
-        --% Diacritical marks
-        quote:   $ -> $
-          ++ quote(f) creates the form f with a prefix quote.
-        dot:     $ -> $
-          ++ dot(f) creates the form with a one dot overhead.
-        dot:     ($, NonNegativeInteger) -> $
-          ++ dot(f,n) creates the form f with n dots overhead.
-        prime:   $ -> $
-          ++ prime(f) creates the form f followed by a suffix prime (single quote).
-        prime:   ($, NonNegativeInteger) -> $
-          ++ prime(f,n) creates the form f followed by n primes.
-        overbar: $ -> $
-          ++ overbar(f) creates the form f with an overbar.
-        overlabel: ($, $) -> $
-          ++ overlabel(x,f) creates the form f with "x overbar" over the top.
-
-        --% Plexes
-        sum:     ($)       -> $
-          ++ sum(expr) creates the form prefixing expr by a capital sigma.
-        sum:     ($, $)    -> $
-          ++ sum(expr,lowerlimit) creates the form prefixing expr by
-          ++ a capital sigma with a lowerlimit.
-        sum:     ($, $, $) -> $
-          ++ sum(expr,lowerlimit,upperlimit) creates the form prefixing expr by
-          ++ a capital sigma with both a lowerlimit and upperlimit.
-        prod:    ($)       -> $
-          ++ prod(expr) creates the form prefixing expr by a capital pi.
-        prod:    ($, $)    -> $
-          ++ prod(expr,lowerlimit) creates the form prefixing expr by
-          ++ a capital pi with a lowerlimit.
-        prod:    ($, $, $) -> $
-          ++ prod(expr,lowerlimit,upperlimit) creates the form prefixing expr by
-          ++ a capital pi with both a lowerlimit and upperlimit.
-        int:     ($)       -> $
-          ++ int(expr) creates the form prefixing expr with an integral sign.
-        int:     ($, $)    -> $
-          ++ int(expr,lowerlimit) creates the form prefixing expr by an
-          ++ integral sign with a lowerlimit.
-        int:     ($, $, $) -> $
-          ++ int(expr,lowerlimit,upperlimit) creates the form prefixing expr by
-          ++ an integral sign with both a lowerlimit and upperlimit.
-
-        --% Matchfix forms
-        brace:   $ -> $
-          ++ brace(f) creates the form enclosing f in braces (curly brackets).
-        brace:   List $ -> $
-          ++ brace(lf) creates the form separating the elements of lf
-          ++ by commas and encloses the result in curly brackets.
-        bracket: $ -> $
-          ++ bracket(f) creates the form enclosing f in square brackets.
-        bracket: List $ -> $
-          ++ bracket(lf) creates the form separating the elements of lf
-          ++ by commas and encloses the result in square brackets.
-        paren:   $ -> $
-          ++ paren(f) creates the form enclosing f in parentheses.
-        paren:   List $ -> $
-          ++ paren(lf) creates the form separating the elements of lf
-          ++ by commas and encloses the result in parentheses.
-
-        --% Separators for aggregates
-        pile:     List $ -> $
-          ++ pile(l) creates the form consisting of the elements of l which
-          ++ displays as a pile, i.e. the elements begin on a new line and
-          ++ are indented right to the same margin.
-
-        commaSeparate: List $ -> $
-          ++ commaSeparate(l) creates the form separating the elements of l
-          ++ by commas.
-        semicolonSeparate:  List $ -> $
-          ++ semicolonSeparate(l) creates the form separating the elements of l
-          ++ by semicolons.
-        blankSeparate: List $ -> $
-          ++ blankSeparate(l) creates the form separating the elements of l
-          ++ by blanks.
-        --% Specific applications
-        "=":     ($, $) -> $
-          ++ f = g creates the equivalent infix form.
-        "^=":    ($, $) -> $
-          ++ f ^= g creates the equivalent infix form.
-        "<":     ($, $) -> $
-          ++ f < g creates the equivalent infix form.
-        ">":     ($, $) -> $
-          ++ f > g creates the equivalent infix form.
-        "<=":    ($, $) -> $
-          ++ f <= g creates the equivalent infix form.
-        ">=":    ($, $) -> $
-          ++ f >= g creates the equivalent infix form.
-        "+":     ($, $) -> $
-          ++ f + g creates the equivalent infix form.
-        "-":     ($, $) -> $
-          ++ f - g creates the equivalent infix form.
-        "-":     ($)    -> $
-          ++ - f creates the equivalent prefix form.
-        "*":     ($, $) -> $
-          ++ f * g creates the equivalent infix form.
-        "/":     ($, $) -> $
-          ++ f / g creates the equivalent infix form.
-        "**":    ($, $) -> $
-          ++ f ** g creates the equivalent infix form.
-        "div":   ($, $) -> $
-          ++ f div g creates the equivalent infix form.
-        "rem":   ($, $) -> $
-          ++ f rem g creates the equivalent infix form.
-        "quo":   ($, $) -> $
-          ++ f quo g creates the equivalent infix form.
-        "exquo": ($, $) -> $
-          ++ exquo(f,g) creates the equivalent infix form.
-        "and":   ($, $) -> $
-          ++ f and g creates the equivalent infix form.
-        "or":    ($, $) -> $
-          ++ f or g creates the equivalent infix form.
-        "not":   ($)    -> $
-          ++ not f creates the equivalent prefix form.
-        SEGMENT: ($,$)  -> $
-          ++ SEGMENT(x,y) creates the infix form: \spad{x..y}.
-        SEGMENT: ($)    -> $
-          ++ SEGMENT(x) creates the prefix form: \spad{x..}.
-
-    == add
-        import NumberFormats
-
-        -- Todo:
-        --   program forms, greek letters
-        --   infix, prefix, postfix, matchfix support in OUT BOOT
-        --   labove rabove, corresponding overs.
-        --   better super script, overmark, undermark
-        --   bug in product, paren blankSeparate []
-        --   uniformize integrals, products, etc as plexes.
-
-        cons ==> CONS$Lisp
-        car  ==> CAR$Lisp
-        cdr  ==> CDR$Lisp
-
-        Rep := List $
-
-        a, b: $
-        l: List $
-        s: String
-        e: Symbol
-        n: Integer
-        nn:NonNegativeInteger
-
-        sform:    String  -> $
-        eform:    Symbol  -> $
-        iform:    Integer -> $
-
-        print x              == mathprint(x)$Lisp
-        message s            == (empty? s => empty(); s pretend $)
-        messagePrint s       == print message s
-        (a:$ = b:$):Boolean  == EQUAL(a, b)$Lisp
-        (a:$ = b:$):$        == [sform "=",     a, b]
-        coerce(a):OutputForm  == a pretend OutputForm
-        outputForm n          == n pretend $
-        outputForm e          == e pretend $
-        outputForm(f:DoubleFloat) == f pretend $
-        sform s               == s pretend $
-        eform e               == e pretend $
-        iform n               == n pretend $
-
-        outputForm s ==
-          sform concat(quote()$Character, concat(s, quote()$Character))
-
-        width(a) == outformWidth(a)$Lisp
-        height(a) == height(a)$Lisp
-        subHeight(a) == subspan(a)$Lisp
-        superHeight(a) == superspan(a)$Lisp
-        height() == 20
-        width() == 66
-
-        center(a,w)   == hconcat(hspace((w - width(a)) quo 2),a)
-        left(a,w)     == hconcat(a,hspace((w - width(a))))
-        right(a,w)    == hconcat(hspace(w - width(a)),a)
-        center(a)     == center(a,width())
-        left(a)       == left(a,width())
-        right(a)      == right(a,width())
-
-        vspace(n) ==
-          n = 0 => empty()
-          vconcat(sform " ",vspace(n - 1))
-
-        hspace(n) ==
-          n = 0 => empty()
-          sform(fillerSpaces(n)$Lisp)
-
-        rspace(n, m) ==
-          n = 0 or m = 0 => empty()
-          vconcat(hspace n, rspace(n, m - 1))
-
-        matrix ll ==
-            lv:$ := [LIST2VEC$Lisp l for l in ll]
-            CONS(eform MATRIX, LIST2VEC$Lisp lv)$Lisp
-
-        pile l              == cons(eform SC, l)
-        commaSeparate l     == cons(eform AGGLST,  l)
-        semicolonSeparate l == cons(eform AGGSET,  l)
-        blankSeparate l     ==
-           c:=eform CONCATB
-           l1:$:=[]
-           for u in reverse l repeat
-               if EQCAR(u,c)$Lisp
-                  then l1:=[:cdr u,:l1]
-                  else l1:=[u,:l1]
-           cons(c, l1)
-
-        brace a        == [eform BRACE,   a]
-        brace l        == brace commaSeparate l
-        bracket a      == [eform BRACKET, a]
-        bracket l      == bracket commaSeparate l
-        paren a        == [eform PAREN,   a]
-        paren l        == paren commaSeparate l
-
-        sub     (a,b)  == [eform SUB, a, b]
-        super   (a, b) == [eform SUPERSUB,a,sform " ",b]
-        presub(a,b) == [eform SUPERSUB,a,sform " ",sform " ",sform " ",b]
-        presuper(a, b) == [eform SUPERSUB,a,sform " ",sform " ",b]
-        scripts (a, l) ==
-            null l => a
-            null rest l => sub(a, first l)
-            cons(eform SUPERSUB, cons(a, l))
-        supersub(a, l) ==
-            if odd?(#l) then l := append(l, [empty()])
-            cons(eform ALTSUPERSUB, cons(a, l))
-
-        hconcat(a,b)  == [eform CONCAT, a, b]
-        hconcat l     == cons(eform CONCAT, l)
-        vconcat(a,b)  == [eform VCONCAT, a, b]
-        vconcat l     == cons(eform VCONCAT, l)
-
-        a ^= b      == [sform "^=",    a, b]
-        a < b       == [sform "<",     a, b]
-        a > b       == [sform ">",     a, b]
-        a <= b      == [sform "<=",    a, b]
-        a >= b      == [sform ">=",    a, b]
-
-        a + b       == [sform "+",     a, b]
-        a - b       == [sform "-",     a, b]
-        - a         == [sform "-",     a]
-        a * b       == [sform "*",     a, b]
-        a / b       == [sform "/",     a, b]
-        a ** b      == [sform "**",    a, b]
-        a div b     == [sform "div",   a, b]
-        a rem b     == [sform "rem",   a, b]
-        a quo b     == [sform "quo",   a, b]
-        a exquo b   == [sform "exquo", a, b]
-        a and b     == [sform "and",   a, b]
-        a or b      == [sform "or",    a, b]
-        not a       == [sform "not",   a]
-        SEGMENT(a,b)== [eform SEGMENT, a, b]
-        SEGMENT(a)  == [eform SEGMENT, a]
-        binomial(a,b)==[eform BINOMIAL, a, b]
-
-        empty() == [eform NOTHING]
-
-        infix? a ==
-            e:$ :=
-                IDENTP$Lisp a => a
-                STRINGP$Lisp a => INTERN$Lisp a
-                return false
-            if GET(e,QUOTE(INFIXOP$Lisp)$Lisp)$Lisp then true else false
-
-        elt(a, l) ==
-            cons(a, l)
-        prefix(a,l)   ==
-            not infix? a => cons(a, l)
-            hconcat(a, paren commaSeparate l)
-        infix(a, l) ==
-            null l => empty()
-            null rest l => first l
-            infix? a => cons(a, l)
-            hconcat [first l, a, infix(a, rest l)]
-        infix(a,b,c)  ==
-            infix? a => [a, b, c]
-            hconcat [b, a, c]
-        postfix(a, b) ==
-            hconcat(b, a)
-
-        string a   == [eform STRING,  a]
-        quote  a   == [eform QUOTE,   a]
-        overbar a  == [eform OVERBAR, a]
-        dot a      == super(a, sform ".")
-        prime a    == super(a, sform ",")
-        dot(a,nn)   == (s := new(nn, char "."); super(a, sform s))
-        prime(a,nn) == (s := new(nn, char ","); super(a, sform s))
-
-        overlabel(a,b) == [eform OVERLABEL, a, b]
-        box a      == [eform BOX,     a]
-        zag(a,b)   == [eform ZAG,     a, b]
-        root a     == [eform ROOT,    a]
-        root(a,b)  == [eform ROOT,    a, b]
-        over(a,b)  == [eform OVER,    a, b]
-        slash(a,b) == [eform SLASH,   a, b]
-        assign(a,b)== [eform LET,     a, b]
-
-        label(a,b) == [eform EQUATNUM, a, b]
-        rarrow(a,b)== [eform TAG, a, b]
-        differentiate(a, nn)==
-            zero? nn => a
-            nn < 4 => prime(a, nn)
-            r := FormatRoman(nn::PositiveInteger)
-            s := lowerCase(r::String)
-            super(a, paren sform s)
-
-        sum(a)     == [eform SIGMA,  empty(), a]
-        sum(a,b)   == [eform SIGMA,  b, a]
-        sum(a,b,c) == [eform SIGMA2, b, c, a]
-        prod(a)    == [eform PI,     empty(), a]
-        prod(a,b)  == [eform PI,     b, a]
-        prod(a,b,c)== [eform PI2,    b, c, a]
-        int(a)     == [eform INTSIGN,empty(), empty(), a]
-        int(a,b)   == [eform INTSIGN,b, empty(), a]
-        int(a,b,c) == [eform INTSIGN,b, c, a]
-
-@
-\section{OUTFORM.lsp BOOTSTRAP} 
-{\bf OUTFORM} depends on itself.
-We need to break this cycle to build the algebra. So we keep a
-cached copy of the translated {\bf OUTFORM} category which we can write
-into the {\bf MID} directory. We compile the lisp code and copy the
-{\bf OUTFORM.o} file to the {\bf OUT} directory.  This is eventually
-forcibly replaced by a recompiled version.
-
-Note that this code is not included in the generated catdef.spad file.
-
-<<OUTFORM.lsp BOOTSTRAP>>=
-
-(|/VERSIONCHECK| 2) 
-
-(PUT (QUOTE |OUTFORM;print;$V;1|) (QUOTE |SPADreplace|) (QUOTE |mathprint|)) 
-
-(DEFUN |OUTFORM;print;$V;1| (|x| |$|) (|mathprint| |x|)) 
-
-(DEFUN |OUTFORM;message;S$;2| (|s| |$|) (COND ((SPADCALL |s| (QREFELT |$| 11)) (SPADCALL (QREFELT |$| 12))) ((QUOTE T) |s|))) 
-
-(DEFUN |OUTFORM;messagePrint;SV;3| (|s| |$|) (SPADCALL (SPADCALL |s| (QREFELT |$| 13)) (QREFELT |$| 8))) 
-
-(PUT (QUOTE |OUTFORM;=;2$B;4|) (QUOTE |SPADreplace|) (QUOTE EQUAL)) 
-
-(DEFUN |OUTFORM;=;2$B;4| (|a| |b| |$|) (EQUAL |a| |b|)) 
-
-(DEFUN |OUTFORM;=;3$;5| (|a| |b| |$|) (LIST (|OUTFORM;sform| "=" |$|) |a| |b|)) 
-
-(PUT (QUOTE |OUTFORM;coerce;2$;6|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|a|) |a|))) 
-
-(DEFUN |OUTFORM;coerce;2$;6| (|a| |$|) |a|) 
-
-(PUT (QUOTE |OUTFORM;outputForm;I$;7|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|n|) |n|))) 
-
-(DEFUN |OUTFORM;outputForm;I$;7| (|n| |$|) |n|) 
-
-(PUT (QUOTE |OUTFORM;outputForm;S$;8|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|e|) |e|))) 
-
-(DEFUN |OUTFORM;outputForm;S$;8| (|e| |$|) |e|) 
-
-(PUT (QUOTE |OUTFORM;outputForm;Df$;9|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|f|) |f|))) 
-
-(DEFUN |OUTFORM;outputForm;Df$;9| (|f| |$|) |f|) 
-
-(PUT (QUOTE |OUTFORM;sform|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|s|) |s|))) 
-
-(DEFUN |OUTFORM;sform| (|s| |$|) |s|) 
-
-(PUT (QUOTE |OUTFORM;eform|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|e|) |e|))) 
-
-(DEFUN |OUTFORM;eform| (|e| |$|) |e|) 
-
-(PUT (QUOTE |OUTFORM;iform|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|n|) |n|))) 
-
-(DEFUN |OUTFORM;iform| (|n| |$|) |n|) 
-
-(DEFUN |OUTFORM;outputForm;S$;13| (|s| |$|) (|OUTFORM;sform| (SPADCALL (SPADCALL (QREFELT |$| 26)) (SPADCALL |s| (SPADCALL (QREFELT |$| 26)) (QREFELT |$| 27)) (QREFELT |$| 28)) |$|)) 
-
-(PUT (QUOTE |OUTFORM;width;$I;14|) (QUOTE |SPADreplace|) (QUOTE |outformWidth|)) 
-
-(DEFUN |OUTFORM;width;$I;14| (|a| |$|) (|outformWidth| |a|)) 
-
-(PUT (QUOTE |OUTFORM;height;$I;15|) (QUOTE |SPADreplace|) (QUOTE |height|)) 
-
-(DEFUN |OUTFORM;height;$I;15| (|a| |$|) (|height| |a|)) 
-
-(PUT (QUOTE |OUTFORM;subHeight;$I;16|) (QUOTE |SPADreplace|) (QUOTE |subspan|)) 
-
-(DEFUN |OUTFORM;subHeight;$I;16| (|a| |$|) (|subspan| |a|)) 
-
-(PUT (QUOTE |OUTFORM;superHeight;$I;17|) (QUOTE |SPADreplace|) (QUOTE |superspan|)) 
-
-(DEFUN |OUTFORM;superHeight;$I;17| (|a| |$|) (|superspan| |a|)) 
-
-(PUT (QUOTE |OUTFORM;height;I;18|) (QUOTE |SPADreplace|) (QUOTE (XLAM NIL 20))) 
-
-(DEFUN |OUTFORM;height;I;18| (|$|) 20) 
-
-(PUT (QUOTE |OUTFORM;width;I;19|) (QUOTE |SPADreplace|) (QUOTE (XLAM NIL 66))) 
-
-(DEFUN |OUTFORM;width;I;19| (|$|) 66) 
-
-(DEFUN |OUTFORM;center;$I$;20| (|a| |w| |$|) (SPADCALL (SPADCALL (QUOTIENT2 (|-| |w| (SPADCALL |a| (QREFELT |$| 30))) 2) (QREFELT |$| 36)) |a| (QREFELT |$| 37))) 
-
-(DEFUN |OUTFORM;left;$I$;21| (|a| |w| |$|) (SPADCALL |a| (SPADCALL (|-| |w| (SPADCALL |a| (QREFELT |$| 30))) (QREFELT |$| 36)) (QREFELT |$| 37))) 
-
-(DEFUN |OUTFORM;right;$I$;22| (|a| |w| |$|) (SPADCALL (SPADCALL (|-| |w| (SPADCALL |a| (QREFELT |$| 30))) (QREFELT |$| 36)) |a| (QREFELT |$| 37))) 
-
-(DEFUN |OUTFORM;center;2$;23| (|a| |$|) (SPADCALL |a| (SPADCALL (QREFELT |$| 35)) (QREFELT |$| 38))) 
-
-(DEFUN |OUTFORM;left;2$;24| (|a| |$|) (SPADCALL |a| (SPADCALL (QREFELT |$| 35)) (QREFELT |$| 39))) 
-
-(DEFUN |OUTFORM;right;2$;25| (|a| |$|) (SPADCALL |a| (SPADCALL (QREFELT |$| 35)) (QREFELT |$| 40))) 
-
-(DEFUN |OUTFORM;vspace;I$;26| (|n| |$|) (COND ((EQL |n| 0) (SPADCALL (QREFELT |$| 12))) ((QUOTE T) (SPADCALL (|OUTFORM;sform| " " |$|) (SPADCALL (|-| |n| 1) (QREFELT |$| 44)) (QREFELT |$| 45))))) 
-
-(DEFUN |OUTFORM;hspace;I$;27| (|n| |$|) (COND ((EQL |n| 0) (SPADCALL (QREFELT |$| 12))) ((QUOTE T) (|OUTFORM;sform| (|fillerSpaces| |n|) |$|)))) 
-
-(DEFUN |OUTFORM;rspace;2I$;28| (|n| |m| |$|) (COND ((OR (EQL |n| 0) (EQL |m| 0)) (SPADCALL (QREFELT |$| 12))) ((QUOTE T) (SPADCALL (SPADCALL |n| (QREFELT |$| 36)) (SPADCALL |n| (|-| |m| 1) (QREFELT |$| 46)) (QREFELT |$| 45))))) 
-
-(DEFUN |OUTFORM;matrix;L$;29| (|ll| |$|) (PROG (#1=#:G82748 |l| #2=#:G82749 |lv|) (RETURN (SEQ (LETT |lv| (PROGN (LETT #1# NIL |OUTFORM;matrix;L$;29|) (SEQ (LETT |l| NIL |OUTFORM;matrix;L$;29|) (LETT #2# |ll| |OUTFORM;matrix;L$;29|) G190 (COND ((OR (ATOM #2#) (PROGN (LETT |l| (CAR #2#) |OUTFORM;matrix;L$;29|) NIL)) (GO G191))) (SEQ (EXIT (LETT #1# (CONS (LIST2VEC |l|) #1#) |OUTFORM;matrix;L$;29|))) (LETT #2# (CDR #2#) |OUTFORM;matrix;L$;29|) (GO G190) G191 (EXIT (NREVERSE0 #1#)))) |OUTFORM;matrix;L$;29|) (EXIT (CONS (|OUTFORM;eform| (QUOTE MATRIX) |$|) (LIST2VEC |lv|))))))) 
-
-(DEFUN |OUTFORM;pile;L$;30| (|l| |$|) (CONS (|OUTFORM;eform| (QUOTE SC) |$|) |l|)) 
-
-(DEFUN |OUTFORM;commaSeparate;L$;31| (|l| |$|) (CONS (|OUTFORM;eform| (QUOTE AGGLST) |$|) |l|)) 
-
-(DEFUN |OUTFORM;semicolonSeparate;L$;32| (|l| |$|) (CONS (|OUTFORM;eform| (QUOTE AGGSET) |$|) |l|)) 
-
-(DEFUN |OUTFORM;blankSeparate;L$;33| (|l| |$|) (PROG (|c| |u| #1=#:G82757 |l1|) (RETURN (SEQ (LETT |c| (|OUTFORM;eform| (QUOTE CONCATB) |$|) |OUTFORM;blankSeparate;L$;33|) (LETT |l1| NIL |OUTFORM;blankSeparate;L$;33|) (SEQ (LETT |u| NIL |OUTFORM;blankSeparate;L$;33|) (LETT #1# (SPADCALL |l| (QREFELT |$| 53)) |OUTFORM;blankSeparate;L$;33|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |u| (CAR #1#) |OUTFORM;blankSeparate;L$;33|) NIL)) (GO G191))) (SEQ (EXIT (COND ((EQCAR |u| |c|) (LETT |l1| (SPADCALL (CDR |u|) |l1| (QREFELT |$| 54)) |OUTFORM;blankSeparate;L$;33|)) ((QUOTE T) (LETT |l1| (CONS |u| |l1|) |OUTFORM;blankSeparate;L$;33|))))) (LETT #1# (CDR #1#) |OUTFORM;blankSeparate;L$;33|) (GO G190) G191 (EXIT NIL)) (EXIT (CONS |c| |l1|)))))) 
-
-(DEFUN |OUTFORM;brace;2$;34| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE BRACE) |$|) |a|)) 
-
-(DEFUN |OUTFORM;brace;L$;35| (|l| |$|) (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 56))) 
-
-(DEFUN |OUTFORM;bracket;2$;36| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE BRACKET) |$|) |a|)) 
-
-(DEFUN |OUTFORM;bracket;L$;37| (|l| |$|) (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 58))) 
-
-(DEFUN |OUTFORM;paren;2$;38| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE PAREN) |$|) |a|)) 
-
-(DEFUN |OUTFORM;paren;L$;39| (|l| |$|) (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 60))) 
-
-(DEFUN |OUTFORM;sub;3$;40| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SUB) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;super;3$;41| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SUPERSUB) |$|) |a| (|OUTFORM;sform| " " |$|) |b|)) 
-
-(DEFUN |OUTFORM;presub;3$;42| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SUPERSUB) |$|) |a| (|OUTFORM;sform| " " |$|) (|OUTFORM;sform| " " |$|) (|OUTFORM;sform| " " |$|) |b|)) 
-
-(DEFUN |OUTFORM;presuper;3$;43| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SUPERSUB) |$|) |a| (|OUTFORM;sform| " " |$|) (|OUTFORM;sform| " " |$|) |b|)) 
-
-(DEFUN |OUTFORM;scripts;$L$;44| (|a| |l| |$|) (COND ((SPADCALL |l| (QREFELT |$| 66)) |a|) ((SPADCALL (SPADCALL |l| (QREFELT |$| 67)) (QREFELT |$| 66)) (SPADCALL |a| (SPADCALL |l| (QREFELT |$| 68)) (QREFELT |$| 62))) ((QUOTE T) (CONS (|OUTFORM;eform| (QUOTE SUPERSUB) |$|) (CONS |a| |l|))))) 
-
-(DEFUN |OUTFORM;supersub;$L$;45| (|a| |l| |$|) (SEQ (COND ((ODDP (SPADCALL |l| (QREFELT |$| 71))) (LETT |l| (SPADCALL |l| (LIST (SPADCALL (QREFELT |$| 12))) (QREFELT |$| 73)) |OUTFORM;supersub;$L$;45|))) (EXIT (CONS (|OUTFORM;eform| (QUOTE ALTSUPERSUB) |$|) (CONS |a| |l|))))) 
-
-(DEFUN |OUTFORM;hconcat;3$;46| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE CONCAT) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;hconcat;L$;47| (|l| |$|) (CONS (|OUTFORM;eform| (QUOTE CONCAT) |$|) |l|)) 
-
-(DEFUN |OUTFORM;vconcat;3$;48| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE VCONCAT) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;vconcat;L$;49| (|l| |$|) (CONS (|OUTFORM;eform| (QUOTE VCONCAT) |$|) |l|)) 
-
-(DEFUN |OUTFORM;^=;3$;50| (|a| |b| |$|) (LIST (|OUTFORM;sform| "^=" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;<;3$;51| (|a| |b| |$|) (LIST (|OUTFORM;sform| "<" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;>;3$;52| (|a| |b| |$|) (LIST (|OUTFORM;sform| ">" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;<=;3$;53| (|a| |b| |$|) (LIST (|OUTFORM;sform| "<=" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;>=;3$;54| (|a| |b| |$|) (LIST (|OUTFORM;sform| ">=" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;+;3$;55| (|a| |b| |$|) (LIST (|OUTFORM;sform| "+" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;-;3$;56| (|a| |b| |$|) (LIST (|OUTFORM;sform| "-" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;-;2$;57| (|a| |$|) (LIST (|OUTFORM;sform| "-" |$|) |a|)) 
-
-(DEFUN |OUTFORM;*;3$;58| (|a| |b| |$|) (LIST (|OUTFORM;sform| "*" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;/;3$;59| (|a| |b| |$|) (LIST (|OUTFORM;sform| "/" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;**;3$;60| (|a| |b| |$|) (LIST (|OUTFORM;sform| "**" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;div;3$;61| (|a| |b| |$|) (LIST (|OUTFORM;sform| "div" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;rem;3$;62| (|a| |b| |$|) (LIST (|OUTFORM;sform| "rem" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;quo;3$;63| (|a| |b| |$|) (LIST (|OUTFORM;sform| "quo" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;exquo;3$;64| (|a| |b| |$|) (LIST (|OUTFORM;sform| "exquo" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;and;3$;65| (|a| |b| |$|) (LIST (|OUTFORM;sform| "and" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;or;3$;66| (|a| |b| |$|) (LIST (|OUTFORM;sform| "or" |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;not;2$;67| (|a| |$|) (LIST (|OUTFORM;sform| "not" |$|) |a|)) 
-
-(DEFUN |OUTFORM;SEGMENT;3$;68| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SEGMENT) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;SEGMENT;2$;69| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE SEGMENT) |$|) |a|)) 
-
-(DEFUN |OUTFORM;binomial;3$;70| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE BINOMIAL) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;empty;$;71| (|$|) (LIST (|OUTFORM;eform| (QUOTE NOTHING) |$|))) 
-
-(DEFUN |OUTFORM;infix?;$B;72| (|a| |$|) (PROG (#1=#:G82802 |e|) (RETURN (SEQ (EXIT (SEQ (LETT |e| (COND ((IDENTP |a|) |a|) ((STRINGP |a|) (INTERN |a|)) ((QUOTE T) (PROGN (LETT #1# (QUOTE NIL) |OUTFORM;infix?;$B;72|) (GO #1#)))) |OUTFORM;infix?;$B;72|) (EXIT (COND ((GET |e| (QUOTE INFIXOP)) (QUOTE T)) ((QUOTE T) (QUOTE NIL)))))) #1# (EXIT #1#))))) 
-
-(PUT (QUOTE |OUTFORM;elt;$L$;73|) (QUOTE |SPADreplace|) (QUOTE CONS)) 
-
-(DEFUN |OUTFORM;elt;$L$;73| (|a| |l| |$|) (CONS |a| |l|)) 
-
-(DEFUN |OUTFORM;prefix;$L$;74| (|a| |l| |$|) (COND ((NULL (SPADCALL |a| (QREFELT |$| 98))) (CONS |a| |l|)) ((QUOTE T) (SPADCALL |a| (SPADCALL (SPADCALL |l| (QREFELT |$| 51)) (QREFELT |$| 60)) (QREFELT |$| 37))))) 
-
-(DEFUN |OUTFORM;infix;$L$;75| (|a| |l| |$|) (COND ((SPADCALL |l| (QREFELT |$| 66)) (SPADCALL (QREFELT |$| 12))) ((SPADCALL (SPADCALL |l| (QREFELT |$| 67)) (QREFELT |$| 66)) (SPADCALL |l| (QREFELT |$| 68))) ((SPADCALL |a| (QREFELT |$| 98)) (CONS |a| |l|)) ((QUOTE T) (SPADCALL (LIST (SPADCALL |l| (QREFELT |$| 68)) |a| (SPADCALL |a| (SPADCALL |l| (QREFELT |$| 101)) (QREFELT |$| 102))) (QREFELT |$| 75))))) 
-
-(DEFUN |OUTFORM;infix;4$;76| (|a| |b| |c| |$|) (COND ((SPADCALL |a| (QREFELT |$| 98)) (LIST |a| |b| |c|)) ((QUOTE T) (SPADCALL (LIST |b| |a| |c|) (QREFELT |$| 75))))) 
-
-(DEFUN |OUTFORM;postfix;3$;77| (|a| |b| |$|) (SPADCALL |b| |a| (QREFELT |$| 37))) 
-
-(DEFUN |OUTFORM;string;2$;78| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE STRING) |$|) |a|)) 
-
-(DEFUN |OUTFORM;quote;2$;79| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE QUOTE) |$|) |a|)) 
-
-(DEFUN |OUTFORM;overbar;2$;80| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE OVERBAR) |$|) |a|)) 
-
-(DEFUN |OUTFORM;dot;2$;81| (|a| |$|) (SPADCALL |a| (|OUTFORM;sform| "." |$|) (QREFELT |$| 63))) 
-
-(DEFUN |OUTFORM;prime;2$;82| (|a| |$|) (SPADCALL |a| (|OUTFORM;sform| "," |$|) (QREFELT |$| 63))) 
-
-(DEFUN |OUTFORM;dot;$Nni$;83| (|a| |nn| |$|) (PROG (|s|) (RETURN (SEQ (LETT |s| (|MAKE-FULL-CVEC| |nn| (SPADCALL "." (QREFELT |$| 110))) |OUTFORM;dot;$Nni$;83|) (EXIT (SPADCALL |a| (|OUTFORM;sform| |s| |$|) (QREFELT |$| 63))))))) 
-
-(DEFUN |OUTFORM;prime;$Nni$;84| (|a| |nn| |$|) (PROG (|s|) (RETURN (SEQ (LETT |s| (|MAKE-FULL-CVEC| |nn| (SPADCALL "," (QREFELT |$| 110))) |OUTFORM;prime;$Nni$;84|) (EXIT (SPADCALL |a| (|OUTFORM;sform| |s| |$|) (QREFELT |$| 63))))))) 
-
-(DEFUN |OUTFORM;overlabel;3$;85| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE OVERLABEL) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;box;2$;86| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE BOX) |$|) |a|)) 
-
-(DEFUN |OUTFORM;zag;3$;87| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE ZAG) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;root;2$;88| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE ROOT) |$|) |a|)) 
-
-(DEFUN |OUTFORM;root;3$;89| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE ROOT) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;over;3$;90| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE OVER) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;slash;3$;91| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SLASH) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;assign;3$;92| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE LET) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;label;3$;93| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE EQUATNUM) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;rarrow;3$;94| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE TAG) |$|) |a| |b|)) 
-
-(DEFUN |OUTFORM;differentiate;$Nni$;95| (|a| |nn| |$|) (PROG (#1=#:G82832 |r| |s|) (RETURN (SEQ (COND ((ZEROP |nn|) |a|) ((|<| |nn| 4) (SPADCALL |a| |nn| (QREFELT |$| 112))) ((QUOTE T) (SEQ (LETT |r| (SPADCALL (PROG1 (LETT #1# |nn| |OUTFORM;differentiate;$Nni$;95|) (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#)) (QREFELT |$| 125)) |OUTFORM;differentiate;$Nni$;95|) (LETT |s| (SPADCALL |r| (QREFELT |$| 126)) |OUTFORM;differentiate;$Nni$;95|) (EXIT (SPADCALL |a| (SPADCALL (|OUTFORM;sform| |s| |$|) (QREFELT |$| 60)) (QREFELT |$| 63)))))))))) 
-
-(DEFUN |OUTFORM;sum;2$;96| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE SIGMA) |$|) (SPADCALL (QREFELT |$| 12)) |a|)) 
-
-(DEFUN |OUTFORM;sum;3$;97| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE SIGMA) |$|) |b| |a|)) 
-
-(DEFUN |OUTFORM;sum;4$;98| (|a| |b| |c| |$|) (LIST (|OUTFORM;eform| (QUOTE SIGMA2) |$|) |b| |c| |a|)) 
-
-(DEFUN |OUTFORM;prod;2$;99| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE PI) |$|) (SPADCALL (QREFELT |$| 12)) |a|)) 
-
-(DEFUN |OUTFORM;prod;3$;100| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE PI) |$|) |b| |a|)) 
-
-(DEFUN |OUTFORM;prod;4$;101| (|a| |b| |c| |$|) (LIST (|OUTFORM;eform| (QUOTE PI2) |$|) |b| |c| |a|)) 
-
-(DEFUN |OUTFORM;int;2$;102| (|a| |$|) (LIST (|OUTFORM;eform| (QUOTE INTSIGN) |$|) (SPADCALL (QREFELT |$| 12)) (SPADCALL (QREFELT |$| 12)) |a|)) 
-
-(DEFUN |OUTFORM;int;3$;103| (|a| |b| |$|) (LIST (|OUTFORM;eform| (QUOTE INTSIGN) |$|) |b| (SPADCALL (QREFELT |$| 12)) |a|)) 
-
-(DEFUN |OUTFORM;int;4$;104| (|a| |b| |c| |$|) (LIST (|OUTFORM;eform| (QUOTE INTSIGN) |$|) |b| |c| |a|)) 
-
-(DEFUN |OutputForm| NIL (PROG NIL (RETURN (PROG (#1=#:G82846) (RETURN (COND ((LETT #1# (HGET |$ConstructorCache| (QUOTE |OutputForm|)) |OutputForm|) (|CDRwithIncrement| (CDAR #1#))) ((QUOTE T) (|UNWIND-PROTECT| (PROG1 (CDDAR (HPUT |$ConstructorCache| (QUOTE |OutputForm|) (LIST (CONS NIL (CONS 1 (|OutputForm;|)))))) (LETT #1# T |OutputForm|)) (COND ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |OutputForm|)))))))))))) 
-
-(DEFUN |OutputForm;| NIL (PROG (|dv$| |$| |pv$|) (RETURN (PROGN (LETT |dv$| (QUOTE (|OutputForm|)) . #1=(|OutputForm|)) (LETT |$| (GETREFV 138) . #1#) (QSETREFV |$| 0 |dv$|) (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#)) (|haddProp| |$ConstructorCache| (QUOTE |OutputForm|) NIL (CONS 1 |$|)) (|stuffDomainSlots| |$|) (QSETREFV |$| 6 (|List| |$|)) |$|)))) 
-
-(MAKEPROP (QUOTE |OutputForm|) (QUOTE |infovec|) (LIST (QUOTE #(NIL NIL NIL NIL NIL NIL (QUOTE |Rep|) (|Void|) |OUTFORM;print;$V;1| (|Boolean|) (|String|) (0 . |empty?|) |OUTFORM;empty;$;71| |OUTFORM;message;S$;2| |OUTFORM;messagePrint;SV;3| |OUTFORM;=;2$B;4| |OUTFORM;=;3$;5| (|OutputForm|) |OUTFORM;coerce;2$;6| (|Integer|) |OUTFORM;outputForm;I$;7| (|Symbol|) |OUTFORM;outputForm;S$;8| (|DoubleFloat|) |OUTFORM;outputForm;Df$;9| (|Character|) (5 . |quote|) (9 . |concat|) (15 . |concat|) |OUTFORM;outputForm;S$;13| |OUTFORM;width;$I;14| |OUTFORM;height;$I;15| |OUTFORM;subHeight;$I;16| |OUTFORM;superHeight;$I;17| |OUTFORM;height;I;18| |OUTFORM;width;I;19| |OUTFORM;hspace;I$;27| |OUTFORM;hconcat;3$;46| |OUTFORM;center;$I$;20| |OUTFORM;left;$I$;21| |OUTFORM;right;$I$;22| |OUTFORM;center;2$;23| |OUTFORM;left;2$;24| |OUTFORM;right;2$;25| |OUTFORM;vspace;I$;26| |OUTFORM;vconcat;3$;48| |OUTFORM;rspace;2I$;28| (|List| 49) |OUTFORM;matrix;L$;29| (|List| |$|) |OUTFORM;pile;L$;30| |OUTFORM;commaSeparate;L$;31| |OUTFORM;semicolonSeparate;L$;32| (21 . |reverse|) (26 . |append|) |OUTFORM;blankSeparate;L$;33| |OUTFORM;brace;2$;34| |OUTFORM;brace;L$;35| |OUTFORM;bracket;2$;36| |OUTFORM;bracket;L$;37| |OUTFORM;paren;2$;38| |OUTFORM;paren;L$;39| |OUTFORM;sub;3$;40| |OUTFORM;super;3$;41| |OUTFORM;presub;3$;42| |OUTFORM;presuper;3$;43| (32 . |null|) (37 . |rest|) (42 . |first|) |OUTFORM;scripts;$L$;44| (|NonNegativeInteger|) (47 . |#|) (|List| |$$|) (52 . |append|) |OUTFORM;supersub;$L$;45| |OUTFORM;hconcat;L$;47| |OUTFORM;vconcat;L$;49| |OUTFORM;^=;3$;50| |OUTFORM;<;3$;51| |OUTFORM;>;3$;52| |OUTFORM;<=;3$;53| |OUTFORM;>=;3$;54| |OUTFORM;+;3$;55| |OUTFORM;-;3$;56| |OUTFORM;-;2$;57| |OUTFORM;*;3$;58| |OUTFORM;/;3$;59| |OUTFORM;**;3$;60| |OUTFORM;div;3$;61| |OUTFORM;rem;3$;62| |OUTFORM;quo;3$;63| |OUTFORM;exquo;3$;64| |OUTFORM;and;3$;65| |OUTFORM;or;3$;66| |OUTFORM;not;2$;67| |OUTFORM;SEGMENT;3$;68| |OUTFORM;SEGMENT;2$;69| |OUTFORM;binomial;3$;70| |OUTFORM;infix?;$B;72| |OUTFORM;elt;$L$;73| |OUTFORM;prefix;$L$;74| (58 . |rest|) |OUTFORM;infix;$L$;75| |OUTFORM;infix;4$;76| |OUTFORM;postfix;3$;77| |OUTFORM;string;2$;78| |OUTFORM;quote;2$;79| |OUTFORM;overbar;2$;80| |OUTFORM;dot;2$;81| |OUTFORM;prime;2$;82| (63 . |char|) |OUTFORM;dot;$Nni$;83| |OUTFORM;prime;$Nni$;84| |OUTFORM;overlabel;3$;85| |OUTFORM;box;2$;86| |OUTFORM;zag;3$;87| |OUTFORM;root;2$;88| |OUTFORM;root;3$;89| |OUTFORM;over;3$;90| |OUTFORM;slash;3$;91| |OUTFORM;assign;3$;92| |OUTFORM;label;3$;93| |OUTFORM;rarrow;3$;94| (|PositiveInteger|) (|NumberFormats|) (68 . |FormatRoman|) (73 . |lowerCase|) |OUTFORM;differentiate;$Nni$;95| |OUTFORM;sum;2$;96| |OUTFORM;sum;3$;97| |OUTFORM;sum;4$;98| |OUTFORM;prod;2$;99| |OUTFORM;prod;3$;100| |OUTFORM;prod;4$;101| |OUTFORM;int;2$;102| |OUTFORM;int;3$;103| |OUTFORM;int;4$;104| (|SingleInteger|))) (QUOTE #(|~=| 78 |zag| 84 |width| 90 |vspace| 99 |vconcat| 104 |supersub| 115 |superHeight| 121 |super| 126 |sum| 132 |subHeight| 150 |sub| 155 |string| 161 |slash| 166 |semicolonSeparate| 172 |scripts| 177 |rspace| 183 |root| 189 |right| 200 |rem| 211 |rarrow| 217 |quote| 223 |quo| 228 |prod| 234 |print| 252 |prime| 257 |presuper| 268 |presub| 274 |prefix| 280 |postfix| 286 |pile| 292 |paren| 297 |overlabel| 307 |overbar| 313 |over| 318 |outputForm| 324 |or| 344 |not| 350 |messagePrint| 355 |message| 360 |matrix| 365 |left| 370 |latex| 381 |label| 386 |int| 392 |infix?| 410 |infix| 415 |hspace| 428 |height| 433 |hconcat| 442 |hash| 453 |exquo| 458 |empty| 464 |elt| 468 |dot| 474 |div| 485 |differentiate| 491 |commaSeparate| 497 |coerce| 502 |center| 507 |bracket| 518 |brace| 528 |box| 538 |blankSeparate| 543 |binomial| 548 |assign| 554 |and| 560 |^=| 566 SEGMENT 572 |>=| 583 |>| 589 |=| 595 |<=| 607 |<| 613 |/| 619 |-| 625 |+| 636 |**| 642 |*| 648)) (QUOTE NIL) (CONS (|makeByteWordVec2| 1 (QUOTE (0 0 0))) (CONS (QUOTE #(|SetCategory&| |BasicType&| NIL)) (CONS (QUOTE #((|SetCategory|) (|BasicType|) (|CoercibleTo| 17))) (|makeByteWordVec2| 137 (QUOTE (1 10 9 0 11 0 25 0 26 2 10 0 0 25 27 2 10 0 25 0 28 1 6 0 0 53 2 6 0 0 0 54 1 6 9 0 66 1 6 0 0 67 1 6 2 0 68 1 6 70 0 71 2 72 0 0 0 73 1 72 0 0 101 1 25 0 10 110 1 124 10 123 125 1 10 0 0 126 2 0 9 0 0 1 2 0 0 0 0 115 0 0 19 35 1 0 19 0 30 1 0 0 19 44 1 0 0 49 76 2 0 0 0 0 45 2 0 0 0 49 74 1 0 19 0 33 2 0 0 0 0 63 2 0 0 0 0 129 3 0 0 0 0 0 130 1 0 0 0 128 1 0 19 0 32 2 0 0 0 0 62 1 0 0 0 105 2 0 0 0 0 119 1 0 0 49 52 2 0 0 0 49 69 2 0 0 19 19 46 1 0 0 0 116 2 0 0 0 0 117 1 0 0 0 43 2 0 0 0 19 40 2 0 0 0 0 89 2 0 0 0 0 122 1 0 0 0 106 2 0 0 0 0 90 3 0 0 0 0 0 133 1 0 0 0 131 2 0 0 0 0 132 1 0 7 0 8 2 0 0 0 70 112 1 0 0 0 109 2 0 0 0 0 65 2 0 0 0 0 64 2 0 0 0 49 100 2 0 0 0 0 104 1 0 0 49 50 1 0 0 49 61 1 0 0 0 60 2 0 0 0 0 113 1 0 0 0 107 2 0 0 0 0 118 1 0 0 10 29 1 0 0 23 24 1 0 0 21 22 1 0 0 19 20 2 0 0 0 0 93 1 0 0 0 94 1 0 7 10 14 1 0 0 10 13 1 0 0 47 48 1 0 0 0 42 2 0 0 0 19 39 1 0 10 0 1 2 0 0 0 0 121 3 0 0 0 0 0 136 2 0 0 0 0 135 1 0 0 0 134 1 0 9 0 98 2 0 0 0 49 102 3 0 0 0 0 0 103 1 0 0 19 36 0 0 19 34 1 0 19 0 31 1 0 0 49 75 2 0 0 0 0 37 1 0 137 0 1 2 0 0 0 0 91 0 0 0 12 2 0 0 0 49 99 2 0 0 0 70 111 1 0 0 0 108 2 0 0 0 0 88 2 0 0 0 70 127 1 0 0 49 51 1 0 17 0 18 1 0 0 0 41 2 0 0 0 19 38 1 0 0 0 58 1 0 0 49 59 1 0 0 49 57 1 0 0 0 56 1 0 0 0 114 1 0 0 49 55 2 0 0 0 0 97 2 0 0 0 0 120 2 0 0 0 0 92 2 0 0 0 0 77 1 0 0 0 96 2 0 0 0 0 95 2 0 0 0 0 81 2 0 0 0 0 79 2 0 0 0 0 16 2 0 9 0 0 15 2 0 0 0 0 80 2 0 0 0 0 78 2 0 0 0 0 86 1 0 0 0 84 2 0 0 0 0 83 2 0 0 0 0 82 2 0 0 0 0 87 2 0 0 0 0 85)))))) (QUOTE |lookupComplete|))) 
-
-(MAKEPROP (QUOTE |OutputForm|) (QUOTE NILADIC) T) 
-@
 \section{License}
 <<license>>=
 --Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
@@ -955,7 +239,6 @@ Note that this code is not included in the generated catdef.spad file.
 <<license>>
 
 <<package NUMFMT NumberFormats>>
-<<domain OUTFORM OutputForm>>
 @
 \eject
 \begin{thebibliography}{99}
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 34d60cf..6dbfd08 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -794,7 +794,7 @@ bookvol10.3 add domains<br/>
 <a href="patches/20081210.01.tpd.patch">20081210.01.tpd.patch</a>
 bookvol10.3 add domains<br/>
 <a href="patches/20081211.01.tpd.patch">20081211.01.tpd.patch</a>
-<br/>
+regression test suite cleanup<br/>
 
  </body>
 </html>
\ No newline at end of file