Initial population.

1 files changed, 577 insertions, 0 deletions

diff --git a/src/algebra/algfunc.spad.pamphlet b/src/algebra/algfunc.spad.pamphlet
new file mode 100644
index 00000000..163734e3
--- /dev/null
+++ b/src/algebra/algfunc.spad.pamphlet
@@ -0,0 +1,577 @@
+\documentclass{article}
+\usepackage{axiom}
+\begin{document}
+\title{\$SPAD/src/algebra algfunc.spad}
+\author{Manuel Bronstein}
+\maketitle
+\begin{abstract}
+\end{abstract}
+\eject
+\tableofcontents
+\eject
+\section{category ACF AlgebraicallyClosedField}
+<<category ACF AlgebraicallyClosedField>>=
+)abbrev category ACF AlgebraicallyClosedField
+++ Author: Manuel Bronstein
+++ Date Created: 22 Mar 1988
+++ Date Last Updated: 27 November 1991
+++ Description:
+++   Model for algebraically closed fields.
+++ Keywords: algebraic, closure, field.
+
+AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with
+    rootOf: Polynomial $ -> $
+      ++ rootOf(p) returns y such that \spad{p(y) = 0}.
+      ++ Error: if p has more than one variable y.
+    rootOf: SparseUnivariatePolynomial $ -> $
+      ++ rootOf(p) returns y such that \spad{p(y) = 0}.
+    rootOf: (SparseUnivariatePolynomial $, Symbol) -> $
+      ++ rootOf(p, y) returns y such that \spad{p(y) = 0}.
+      ++ The object returned displays as \spad{'y}.
+    rootsOf: Polynomial $ -> List $
+      ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ Note: the returned symbols y1,...,yn are bound in the
+      ++ interpreter to respective root values.
+      ++ Error: if p has more than one variable y.
+    rootsOf: SparseUnivariatePolynomial $ -> List $
+      ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+    rootsOf: (SparseUnivariatePolynomial $, Symbol) -> List $
+      ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0};
+      ++ The returned roots display as \spad{'y1},...,\spad{'yn}.
+      ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+    zeroOf: Polynomial $ -> $
+      ++ zeroOf(p) returns y such that \spad{p(y) = 0}.
+      ++ If possible, y is expressed in terms of radicals.
+      ++ Otherwise it is an implicit algebraic quantity.
+      ++ Error: if p has more than one variable y.
+    zeroOf: SparseUnivariatePolynomial $ -> $
+      ++ zeroOf(p) returns y such that \spad{p(y) = 0};
+      ++ if possible, y is expressed in terms of radicals.
+      ++ Otherwise it is an implicit algebraic quantity.
+    zeroOf: (SparseUnivariatePolynomial $, Symbol) -> $
+      ++ zeroOf(p, y) returns y such that \spad{p(y) = 0};
+      ++ if possible, y is expressed in terms of radicals.
+      ++ Otherwise it is an implicit algebraic quantity which
+      ++ displays as \spad{'y}.
+    zerosOf: Polynomial $ -> List $
+      ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ The yi's are expressed in radicals if possible.
+      ++ Otherwise they are implicit algebraic quantities.
+      ++ The returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+      ++ Error: if p has more than one variable y.
+    zerosOf: SparseUnivariatePolynomial $ -> List $
+      ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ The yi's are expressed in radicals if possible, and otherwise
+      ++ as implicit algebraic quantities.
+      ++ The returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+    zerosOf: (SparseUnivariatePolynomial $, Symbol) -> List $
+      ++ zerosOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ The yi's are expressed in radicals if possible, and otherwise
+      ++ as implicit algebraic quantities
+      ++ which display as \spad{'yi}.
+      ++ The returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+ add
+    SUP ==> SparseUnivariatePolynomial $
+
+    assign  : (Symbol, $) -> $
+    allroots: (SUP, Symbol, (SUP, Symbol) -> $) -> List $
+    binomialRoots: (SUP, Symbol, (SUP, Symbol) -> $) -> List $
+
+    zeroOf(p:SUP)            == assign(x := new(), zeroOf(p, x))
+    rootOf(p:SUP)            == assign(x := new(), rootOf(p, x))
+    zerosOf(p:SUP)           == zerosOf(p, new())
+    rootsOf(p:SUP)           == rootsOf(p, new())
+    rootsOf(p:SUP, y:Symbol) == allroots(p, y, rootOf)
+    zerosOf(p:SUP, y:Symbol) == allroots(p, y, zeroOf)
+    assign(x, f)             == (assignSymbol(x, f, $)$Lisp; f)
+
+    zeroOf(p:Polynomial $) ==
+      empty?(l := variables p) => error "zeroOf: constant polynomial"
+      zeroOf(univariate p, first l)
+
+    rootOf(p:Polynomial $) ==
+      empty?(l := variables p) => error "rootOf: constant polynomial"
+      rootOf(univariate p, first l)
+
+    zerosOf(p:Polynomial $) ==
+      empty?(l := variables p) => error "zerosOf: constant polynomial"
+      zerosOf(univariate p, first l)
+
+    rootsOf(p:Polynomial $) ==
+      empty?(l := variables p) => error "rootsOf: constant polynomial"
+      rootsOf(univariate p, first l)
+
+    zeroOf(p:SUP, y:Symbol) ==
+      zero?(d := degree p) => error "zeroOf: constant polynomial"
+      zero? coefficient(p, 0) => 0
+      a := leadingCoefficient p
+      d = 2 =>
+        b := coefficient(p, 1)
+        (sqrt(b**2 - 4 * a * coefficient(p, 0)) - b) / (2 * a)
+      (r := retractIfCan(reductum p)@Union($,"failed")) case "failed" =>
+        rootOf(p, y)
+      nthRoot(- (r::$ / a), d)
+
+    binomialRoots(p, y, fn) ==
+     -- p = a * x**n + b
+      alpha := assign(x := new(y)$Symbol, fn(p, x))
+--      one?(n := degree p) =>  [ alpha ]
+      ((n := degree p) = 1) =>  [ alpha ]
+      cyclo := cyclotomic(n, monomial(1,1)$SUP)$NumberTheoreticPolynomialFunctions(SUP)
+      beta := assign(x := new(y)$Symbol, fn(cyclo, x))
+      [alpha*beta**i for i in 0..(n-1)::NonNegativeInteger]
+
+    import PolynomialDecomposition(SUP,$)
+
+    allroots(p, y, fn) ==
+      zero? p => error "allroots: polynomial must be nonzero"
+      zero? coefficient(p,0) =>
+         concat(0, allroots(p quo monomial(1,1), y, fn))
+      zero?(p1:=reductum p) => empty()
+      zero? reductum p1 => binomialRoots(p, y, fn)
+      decompList := decompose(p)
+      # decompList > 1 =>
+          h := last decompList
+          g := leftFactor(p,h) :: SUP
+          groots := allroots(g, y, fn)
+          "append"/[allroots(h-r::SUP, y, fn) for r in groots]
+      ans := nil()$List($)
+      while not ground? p repeat
+        alpha := assign(x := new(y)$Symbol, fn(p, x))
+        q     := monomial(1, 1)$SUP - alpha::SUP
+        if not zero?(p alpha) then
+          p   := p quo q
+          ans := concat(alpha, ans)
+        else while zero?(p alpha) repeat
+          p   := (p exquo q)::SUP
+          ans := concat(alpha, ans)
+      reverse_! ans
+
+@
+\section{category ACFS AlgebraicallyClosedFunctionSpace}
+<<category ACFS AlgebraicallyClosedFunctionSpace>>=
+)abbrev category ACFS AlgebraicallyClosedFunctionSpace
+++ Author: Manuel Bronstein
+++ Date Created: 31 October 1988
+++ Date Last Updated: 7 October 1991
+++ Description:
+++   Model for algebraically closed function spaces.
+++ Keywords: algebraic, closure, field.
+AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)):
+ Category == Join(AlgebraicallyClosedField, FunctionSpace R) with
+    rootOf : $ -> $
+      ++ rootOf(p) returns y such that \spad{p(y) = 0}.
+      ++ Error: if p has more than one variable y.
+    rootsOf: $ -> List $
+      ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0};
+      ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+      ++ Error: if p has more than one variable y.
+    rootOf : ($, Symbol) -> $
+      ++ rootOf(p,y) returns y such that \spad{p(y) = 0}.
+      ++ The object returned displays as \spad{'y}.
+    rootsOf: ($, Symbol) -> List $
+      ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0};
+      ++ The returned roots display as \spad{'y1},...,\spad{'yn}.
+      ++ Note: the returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+    zeroOf : $ -> $
+      ++ zeroOf(p) returns y such that \spad{p(y) = 0}.
+      ++ The value y is expressed in terms of radicals if possible,and otherwise
+      ++ as an implicit algebraic quantity.
+      ++ Error: if p has more than one variable.
+    zerosOf: $ -> List $
+      ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ The yi's are expressed in radicals if possible.
+      ++ The returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+      ++ Error: if p has more than one variable.
+    zeroOf : ($, Symbol) -> $
+      ++ zeroOf(p, y) returns y such that \spad{p(y) = 0}.
+      ++ The value y is expressed in terms of radicals if possible,and otherwise
+      ++ as an implicit algebraic quantity
+      ++ which displays as \spad{'y}.
+    zerosOf: ($, Symbol) -> List $
+      ++ zerosOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}.
+      ++ The yi's are expressed in radicals if possible, and otherwise
+      ++ as implicit algebraic quantities
+      ++ which display as \spad{'yi}.
+      ++ The returned symbols y1,...,yn are bound in the interpreter
+      ++ to respective root values.
+  add
+    rootOf(p:$) ==
+      empty?(l := variables p) => error "rootOf: constant expression"
+      rootOf(p, first l)
+
+    rootsOf(p:$) ==
+      empty?(l := variables p) => error "rootsOf: constant expression"
+      rootsOf(p, first l)
+
+    zeroOf(p:$) ==
+      empty?(l := variables p) => error "zeroOf: constant expression"
+      zeroOf(p, first l)
+
+    zerosOf(p:$) ==
+      empty?(l := variables p) => error "zerosOf: constant expression"
+      zerosOf(p, first l)
+
+    zeroOf(p:$, x:Symbol) ==
+      n := numer(f := univariate(p, kernel(x)$Kernel($)))
+      degree denom f > 0 => error "zeroOf: variable appears in denom"
+      degree n = 0 => error "zeroOf: constant expression"
+      zeroOf(n, x)
+
+    rootOf(p:$, x:Symbol) ==
+      n := numer(f := univariate(p, kernel(x)$Kernel($)))
+      degree denom f > 0 => error "roofOf: variable appears in denom"
+      degree n = 0 => error "rootOf: constant expression"
+      rootOf(n, x)
+
+    zerosOf(p:$, x:Symbol) ==
+      n := numer(f := univariate(p, kernel(x)$Kernel($)))
+      degree denom f > 0 => error "zerosOf: variable appears in denom"
+      degree n = 0 => empty()
+      zerosOf(n, x)
+
+    rootsOf(p:$, x:Symbol) ==
+      n := numer(f := univariate(p, kernel(x)$Kernel($)))
+      degree denom f > 0 => error "roofsOf: variable appears in denom"
+      degree n = 0 => empty()
+      rootsOf(n, x)
+
+    rootsOf(p:SparseUnivariatePolynomial $, y:Symbol) ==
+      (r := retractIfCan(p)@Union($,"failed")) case $ => rootsOf(r::$,y)
+      rootsOf(p, y)$AlgebraicallyClosedField_&($)
+
+    zerosOf(p:SparseUnivariatePolynomial $, y:Symbol) ==
+      (r := retractIfCan(p)@Union($,"failed")) case $ => zerosOf(r::$,y)
+      zerosOf(p, y)$AlgebraicallyClosedField_&($)
+
+    zeroOf(p:SparseUnivariatePolynomial $, y:Symbol) ==
+      (r := retractIfCan(p)@Union($,"failed")) case $ => zeroOf(r::$, y)
+      zeroOf(p, y)$AlgebraicallyClosedField_&($)
+
+@
+\section{package AF AlgebraicFunction}
+\subsection{hackroot(x, n)}
+This used to read:
+\begin{verbatim}
+      hackroot(x, n) ==
+        (n = 1) or (x = 1) => x
+        (x ^= -1) and (((num := numer x) = 1) or (num = -1)) =>
+           inv hackroot((num * denom x)::F, n)
+        (x = -1) and n = 4 =>
+          ((-1::F) ** (1::Q / 2::Q) + 1) / ((2::F) ** (1::Q / 2::Q))
+        kernel(oproot, [x, n::F])
+
+@
+\end{verbatim}
+but the condition is wrong. For example, if $x$ is negative then
+$x=-1/2$ would pass the
+test and give $$1/(-2)^(1/n) \ne (-1/2)^(1/n)$$
+<<hackroot(x, n)>>=
+      hackroot(x, n) ==
+        (n = 1) or (x = 1) => x
+        (((dx := denom x) ^= 1) and
+           ((rx := retractIfCan(dx)@Union(Integer,"failed")) case Integer) and
+           positive?(rx))
+           => hackroot((numer x)::F, n)/hackroot(rx::Integer::F, n)
+        (x = -1) and n = 4 =>
+          ((-1::F) ** (1::Q / 2::Q) + 1) / ((2::F) ** (1::Q / 2::Q))
+        kernel(oproot, [x, n::F])
+
+@
+<<package AF AlgebraicFunction>>=
+)abbrev package AF AlgebraicFunction
+++ Author: Manuel Bronstein
+++ Date Created: 21 March 1988
+++ Date Last Updated: 11 November 1993
+++ Description:
+++   This package provides algebraic functions over an integral domain.
+++ Keywords: algebraic, function.
+
+AlgebraicFunction(R, F): Exports == Implementation where
+  R: Join(OrderedSet, IntegralDomain)
+  F: FunctionSpace R
+
+  SE  ==> Symbol
+  Z   ==> Integer
+  Q   ==> Fraction Z
+  OP  ==> BasicOperator
+  K   ==> Kernel F
+  P   ==> SparseMultivariatePolynomial(R, K)
+  UP  ==> SparseUnivariatePolynomial F
+  UPR ==> SparseUnivariatePolynomial R
+  ALGOP       ==> "%alg"
+  SPECIALDISP ==> "%specialDisp"
+  SPECIALDIFF ==> "%specialDiff"
+
+  Exports ==> with
+    rootOf  : (UP, SE) -> F
+      ++ rootOf(p, y) returns y such that \spad{p(y) = 0}.
+      ++ The object returned displays as \spad{'y}.
+    operator: OP -> OP
+      ++ operator(op) returns a copy of \spad{op} with the domain-dependent
+      ++ properties appropriate for \spad{F}.
+      ++ Error: if op is not an algebraic operator, that is,
+      ++ an nth root or implicit algebraic operator.
+    belong? : OP -> Boolean
+      ++ belong?(op) is true if \spad{op} is an algebraic operator, that is,
+      ++ an nth root or implicit algebraic operator.
+    inrootof: (UP, F) -> F
+      ++ inrootof(p, x) should be a non-exported function.
+      -- un-export when the compiler accepts conditional local functions!
+    droot : List F -> OutputForm
+      ++ droot(l) should be a non-exported function.
+      -- un-export when the compiler accepts conditional local functions!
+    if R has RetractableTo Integer then
+      "**"   : (F, Q) -> F
+        ++ x ** q is \spad{x} raised to the rational power \spad{q}.
+      minPoly: K  -> UP
+        ++ minPoly(k) returns the defining polynomial of \spad{k}.
+      definingPolynomial: F -> F
+        ++ definingPolynomial(f) returns the defining polynomial of \spad{f}
+        ++ as an element of \spad{F}.
+        ++ Error: if f is not a kernel.
+      iroot : (R, Z) -> F
+        ++ iroot(p, n) should be a non-exported function.
+        -- un-export when the compiler accepts conditional local functions!
+
+  Implementation ==> add
+    ialg : List F -> F
+    dvalg: (List F, SE) -> F
+    dalg : List F -> OutputForm
+
+    opalg  := operator("rootOf"::Symbol)$CommonOperators
+    oproot := operator("nthRoot"::Symbol)$CommonOperators
+
+    belong? op == has?(op, ALGOP)
+    dalg l     == second(l)::OutputForm
+
+    rootOf(p, x) ==
+      k := kernel(x)$K
+      (r := retractIfCan(p)@Union(F, "failed")) case "failed" =>
+        inrootof(p, k::F)
+      n := numer(f := univariate(r::F, k))
+      degree denom f > 0 => error "roofOf: variable appears in denom"
+      inrootof(n, k::F)
+
+    dvalg(l, x) ==
+      p := numer univariate(first l, retract(second l)@K)
+      alpha := kernel(opalg, l)
+      - (map(differentiate(#1, x), p) alpha) / ((differentiate p) alpha)
+
+    ialg l ==
+      f := univariate(p := first l, retract(x := second l)@K)
+      degree denom f > 0 => error "roofOf: variable appears in denom"
+      inrootof(numer f, x)
+
+    operator op ==
+      is?(op,  "rootOf"::Symbol) => opalg
+      is?(op, "nthRoot"::Symbol) => oproot
+      error "Unknown operator"
+
+    if R has AlgebraicallyClosedField then
+      UP2R: UP -> Union(UPR, "failed")
+
+      inrootof(q, x) ==
+        monomial? q => 0
+
+        (d := degree q) <= 0 => error "rootOf: constant polynomial"
+--        one? d=> - leadingCoefficient(reductum q) / leadingCoefficient q
+        (d = 1) => - leadingCoefficient(reductum q) / leadingCoefficient q
+        ((rx := retractIfCan(x)@Union(SE, "failed")) case SE) and
+          ((r := UP2R q) case UPR) => rootOf(r::UPR, rx::SE)::F
+        kernel(opalg, [q x, x])
+
+      UP2R p ==
+        ans:UPR := 0
+        while p ^= 0 repeat
+          (r := retractIfCan(leadingCoefficient p)@Union(R, "failed"))
+            case "failed" => return "failed"
+          ans := ans + monomial(r::R, degree p)
+          p   := reductum p
+        ans
+
+    else
+      inrootof(q, x) ==
+        monomial? q => 0
+        (d := degree q) <= 0 => error "rootOf: constant polynomial"
+--        one? d => - leadingCoefficient(reductum q) /leadingCoefficient q
+        (d = 1) => - leadingCoefficient(reductum q) /leadingCoefficient q
+        kernel(opalg, [q x, x])
+
+    evaluate(opalg, ialg)$BasicOperatorFunctions1(F)
+    setProperty(opalg, SPECIALDIFF,
+                              dvalg@((List F, SE) -> F) pretend None)
+    setProperty(opalg, SPECIALDISP,
+                              dalg@(List F -> OutputForm) pretend None)
+
+    if R has RetractableTo Integer then
+      import PolynomialRoots(IndexedExponents K, K, R, P, F)
+
+      dumvar := "%%var"::Symbol::F
+
+      lzero   : List F -> F
+      dvroot  : List F -> F
+      inroot  : List F -> F
+      hackroot: (F, Z) -> F
+      inroot0 : (F, Z, Boolean, Boolean) -> F
+
+      lzero l == 0
+
+      droot l ==
+        x := first(l)::OutputForm
+        (n := retract(second l)@Z) = 2 => root x
+        root(x, n::OutputForm)
+
+      dvroot l ==
+        n := retract(second l)@Z
+        (first(l) ** ((1 - n) / n)) / (n::F)
+
+      x ** q ==
+        qr := divide(numer q, denom q)
+        x ** qr.quotient * inroot([x, (denom q)::F]) ** qr.remainder
+
+<<hackroot(x, n)>>
+
+      inroot l ==
+        zero?(n := retract(second l)@Z) => error "root: exponent = 0"
+--        one?(x := first l) or one? n => x
+        ((x := first l) = 1) or (n = 1) => x
+        (r := retractIfCan(x)@Union(R,"failed")) case R => iroot(r::R,n)
+        (u := isExpt(x, oproot)) case Record(var:K, exponent:Z) =>
+          pr := u::Record(var:K, exponent:Z)
+          (first argument(pr.var)) **
+              (pr.exponent /$Fraction(Z)
+                   (n * retract(second argument(pr.var))@Z))
+        inroot0(x, n, false, false)
+
+-- removes powers of positive integers from numer and denom
+-- num? or den? is true if numer or denom already processed
+      inroot0(x, n, num?, den?) ==
+        rn:Union(Z, "failed") := (num? => "failed"; retractIfCan numer x)
+        rd:Union(Z, "failed") := (den? => "failed"; retractIfCan denom x)
+        (rn case Z) and (rd case Z) =>
+          rec := qroot(rn::Z / rd::Z, n::NonNegativeInteger)
+          rec.coef * hackroot(rec.radicand, rec.exponent)
+        rn case Z =>
+          rec := qroot(rn::Z::Fraction(Z), n::NonNegativeInteger)
+          rec.coef * inroot0((rec.radicand**(n exquo rec.exponent)::Z)
+                                / (denom(x)::F), n, true, den?)
+        rd case Z =>
+          rec := qroot(rd::Z::Fraction(Z), n::NonNegativeInteger)
+          inroot0((numer(x)::F) /
+                  (rec.radicand ** (n exquo rec.exponent)::Z),
+                   n, num?, true) / rec.coef
+        hackroot(x, n)
+
+      if R has AlgebraicallyClosedField then iroot(r, n) == nthRoot(r, n)::F
+      else
+        iroot0: (R, Z) -> F
+
+        if R has RadicalCategory then
+          if R has imaginary:() -> R then iroot(r, n) == nthRoot(r, n)::F
+          else
+            iroot(r, n) ==
+              odd? n or r >= 0 => nthRoot(r, n)::F
+              iroot0(r, n)
+
+        else iroot(r, n) == iroot0(r, n)
+
+        iroot0(r, n) ==
+          rec := rroot(r, n::NonNegativeInteger)
+          rec.coef * hackroot(rec.radicand, rec.exponent)
+
+      definingPolynomial x ==
+        (r := retractIfCan(x)@Union(K, "failed")) case K =>
+          is?(k := r::K, opalg) => first argument k
+          is?(k, oproot) =>
+            dumvar ** retract(second argument k)@Z - first argument k
+          dumvar - x
+        dumvar - x
+
+      minPoly k ==
+        is?(k, opalg)  =>
+           numer univariate(first argument k,
+                                           retract(second argument k)@K)
+        is?(k, oproot) =>
+           monomial(1,retract(second argument k)@Z :: NonNegativeInteger)
+             - first(argument k)::UP
+        monomial(1, 1) - k::F::UP
+
+      evaluate(oproot, inroot)$BasicOperatorFunctions1(F)
+      derivative(oproot, [dvroot, lzero])
+
+    else   -- R is not retractable to Integer
+      droot l ==
+        x := first(l)::OutputForm
+        (n := second l) = 2::F => root x
+        root(x, n::OutputForm)
+
+      minPoly k ==
+        is?(k, opalg)  =>
+           numer univariate(first argument k,
+                                           retract(second argument k)@K)
+        monomial(1, 1) - k::F::UP
+
+    setProperty(oproot, SPECIALDISP,
+                              droot@(List F -> OutputForm) pretend None)
+
+@
+\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>>
+
+-- SPAD files for the functional world should be compiled in the
+-- following order:
+--
+--   op  kl  fspace ALGFUNC expr
+
+<<category ACF AlgebraicallyClosedField>>
+<<category ACFS AlgebraicallyClosedFunctionSpace>>
+<<package AF AlgebraicFunction>>
+@
+\eject
+\begin{thebibliography}{99}
+\bibitem{1} nothing
+\end{thebibliography}
+\end{document}