login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit
FriCAS Algebra
Complex Polynomial  ← ↑ →  LinearOperator

FreeModule
  
last edited 6 years ago by test1

Edit detail for FreeModule revision 5 of 8
1 2 3 4 5 6 7 8
Editor: page
Time: 2011/03/10 19:17:38 GMT-8
Note: VectorSpace 
added:

Add::

        if R has Field then
             VectorSpace(R)

\begin{spad}
)abbrev category FMCAT FreeModuleCategory
++ Author: Michel Petitot petitot@lifl.fr
++ Date Created: 91
++ Date Last Updated: 7 Juillet 92
++ Fix History: compilation v 2.1 le 13 dec 98
++ Basic Functions:
++ Related Constructors:
++ Also See:
++ AMS Classifications:
++ Keywords:
++ References:
++ Description:
++   A domain of this category
++   implements formal linear combinations
++   of elements from a domain \spad{Basis} with coefficients
++   in a domain \spad{R}. The domain \spad{Basis} needs only
++   to belong to the category \spadtype{SetCategory} and \spad{R}
++   to the category \spadtype{Ring}. Thus the coefficient ring
++   may be non-commutative.
++   See the \spadtype{XDistributedPolynomial} constructor
++   for examples of domains built with the \spadtype{FreeModuleCategory}
++   category constructor.
++   Author: Michel Petitot (petitot@lifl.fr)
++
++   Note (Franz Lehner, June 2009):
++   Since \spad{leadingTerm} makes no sense
++   for unordered base sets,
++   and at the time of this writing this domain was never used for such,
++   it was changed to \spad{OrderedSet}.
++   \spad{FreeModule} originally was not of FreeModuleCategory.
++   Some functions (like \spad{support}, \spad{coefficients},
++   \spad{monomials}, ...) from here could be moved to
++   \spad{IndexedDirectProductCategory}
++   but at the moment there is no need for this.
FreeModuleCategory(R, S):Category == Exports where
   R: Ring
   S: OrderedSet
   Term ==> Record(k: S, c: R)

   Exports == Join(BiModule(R,R), RetractableTo S, IndexedDirectProductCategory(R,S)) with
        "*"                : (R, S) -> %
          ++ \spad{r*b} returns the product of \spad{r} by \spad{b}.
        "*":(S,R) -> %
          ++ \spad{s*r} returns the product \spad{r*s}
          ++ used by \spadtype{XRecursivePolynomial}
        coefficients       : % -> List R
          ++ \spad{coefficients(x)} returns the list of coefficients of \spad{x}.
        support            : % -> List S
          ++ \spad{support(x)} returns the list of basis elements with nonzero coefficients.
        monomials          : % -> List %
          ++ \spad{monomials(x)} returns the list of \spad{r_i*b_i}
          ++ whose sum is \spad{x}.
        numberOfMonomials  : % -> NonNegativeInteger
          ++ \spad{numberOfMonomials(x)} returns the number of monomials of \spad{x}.
        monomial?: % -> Boolean
          ++ \spad{monomial?(x)} returns true if \spad{x} contains a single
          ++ monomial.
        leadingMonomial    : % -> S
          ++ \spad{leadingMonomial(x)} returns the first element from \spad{S}
          ++ which appears in \spad{listOfTerms(x)}.
        leadingCoefficient : % -> R
          ++ \spad{leadingCoefficient(x)} returns the first coefficient
          ++ which appears in \spad{listOfTerms(x)}.
        monom : (S, R) -> %
          ++ \spad{monom(s,r)} returns the product of the basis element \spad{s} by the coefficient \spad{r}.
        coefficient :(%,S) -> R
          ++ \spad{coefficient(x,s)} returns the coefficient of the basis element s
        -- attributes
        if R has Field then
             VectorSpace(R)
        if R has CommutativeRing then
             Module(R)
             linearExtend:(S->R,%)->R
          ++ \spad{linearExtend:(f,x)} returns the linear extension
          ++ of a map defined on the basis applied to a linear combination
        if R has Comparable then Comparable
      add
        if R has Comparable then
          smaller?(p:%,q:%):Boolean ==
            if leadingMonomial(p)=leadingMonomial(q) then
              if leadingCoefficient(p)=leadingCoefficient(q) then
                smaller?(reductum p, reductum q)
              else
                smaller?(leadingCoefficient(p),leadingCoefficient(q))
            leadingMonomial(p)<leadingMonomial(q)
\end{spad}

\begin{spad}
)abbrev domain FM FreeModule
++ Author: Dave Barton, James Davenport, Barry Trager
++ Date Created:
++ Date Last Updated:
++ Basic Functions: BiModule(R,R)
++ Related Constructors:
++ Also See:
++ AMS Classifications:
++ Keywords:
++ References:
++ Description:
++ A bi-module is a free module
++ over a ring with generators indexed by an ordered set.
++ Each element can be expressed as a finite linear combination of
++ generators. Only non-zero terms are stored.

++ old domain FreeModule1 was merged to it in May 2009
++ The description of the latter:
++   This domain implements linear combinations
++   of elements from the domain \spad{S} with coefficients
++   in the domain \spad{R} where \spad{S} is an ordered set
++   and \spad{R} is a ring (which may be non-commutative).
++   This domain is used by domains of non-commutative algebra such as:
++       \spadtype{XDistributedPolynomial},
++       \spadtype{XRecursivePolynomial}.
++   Author: Michel Petitot (petitot@lifl.fr)


FreeModule(R:Ring,S:OrderedSet):
        Join(BiModule(R,R),FreeModuleCategory(R,S)) with
    if R has CommutativeRing then Module(R)
 == IndexedDirectProductAbelianGroup(R,S) add
    --representations
       Term ==>  Record(k:S,c:R)
       Rep :=  List Term
    --declarations
       x,y: %
       r: R
       n: Integer
       f: R -> R
       s: S
       lt: List Term
   --define
       if R has EntireRing then
         r * x  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x+->r*x1,x)
             [[u.k,r*u.c] for u in x ]
       else
         r * x  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x1+->r*x1,x)
             [[u.k,a] for u in x | (a:=r*u.c) ~= 0$R]
       if R has EntireRing then
         x * r  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x1+->r*x1,x)
             [[u.k,u.c*r] for u in x ]
       else
         x * r  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x1+->r*x1,x)
             [[u.k,a] for u in x | (a:=u.c*r) ~= 0$R]

       r * s ==
         r = 0 => 0
         [[s,r]$Term]

       s * r ==
         r = 0 => 0
         [[s,r]$Term]

       coerce(x) : OutputForm ==
         null x => (0$R) :: OutputForm
         le : List OutputForm := nil
         for rec in reverse x repeat
           rec.c = 1 => le := cons(rec.k :: OutputForm, le)
           le := cons(rec.c :: OutputForm *  rec.k :: OutputForm, le)
         reduce("+",le)

       leadingMonomial x == x.first.k

       support x == [t.k for t in x]

       coefficients x == [t.c for t in x]

       monomials x == [ monom (t.k, t.c) for t in x]

       retractIfCan x ==
         numberOfMonomials(x) ~= 1 => "failed"
         x.first.c = 1 => x.first.k
         "failed"

       retract x ==
         (rr := retractIfCan x) case "failed" => error "FM1.retract impossible"
         rr :: S

       coerce(s:S):% == [[s,1$R]]

-- the following is to be replaced by monomial(r,b) everywhere
       monom(b,r):% == [[b,r]$Term]

       coefficient(x,s) ==
         null x => 0$R
         x.first.k > s => coefficient(rest x,s)
         x.first.k = s => x.first.c
         0$R

       monomial? x ==
         numberOfMonomials x = 1

       listOfTerms(x) ==
--          (x::Rep)
--          coerce(x)@Rep
         x pretend Rep

       numberOfMonomials x == # (listOfTerms x)

       if R has CommutativeRing then
           f:S->R
           x:%
           t:Term
           linearExtend(f,x) ==
               zero? x => 0
               res:R:= 0
               for t in listOfTerms x repeat
                   res := res + (t c)*f(t k)
               res
\end{spad}

\begin{axiom}
FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)
\end{axiom}

A bi-module is a free module over a ring with generators indexed by an ordered set. Each element can be expressed as a finite linear combination of generators. Only non-zero terms are stored.

This domain implements linear combinations of elements from the domain S with coefficients in the domain R where S is an ordered set and R is a ring (which may be non-commutative).

Ref: http://en.wikipedia.org/wiki/Free_module

axiom
)sh FreeModule

 FreeModule(R: Ring,S: OrderedSet)  is a domain constructor
 Abbreviation for FreeModule is FM 
 This constructor is not exposed in this frame.
------------------------------- Operations --------------------------------
 ?*? : (R,S) -> %                      ?*? : (S,R) -> %
 ?*? : (%,R) -> %                      ?*? : (R,%) -> %
 ?*? : (Integer,%) -> %                ?*? : (PositiveInteger,%) -> %
 ?+? : (%,%) -> %                      ?-? : (%,%) -> %
 -? : % -> %                           ?=? : (%,%) -> Boolean
 0 : () -> %                           coefficient : (%,S) -> R
 coefficients : % -> List(R)           coerce : S -> %
 coerce : % -> OutputForm              hash : % -> SingleInteger
 latex : % -> String                   leadingCoefficient : % -> R
 leadingMonomial : % -> S              leadingSupport : % -> S
 map : ((R -> R),%) -> %               monom : (S,R) -> %
 monomial : (R,S) -> %                 monomial? : % -> Boolean
 monomials : % -> List(%)              reductum : % -> %
 retract : % -> S                      sample : () -> %
 support : % -> List(S)                zero? : % -> Boolean
 ?~=? : (%,%) -> Boolean              
 ?*? : (NonNegativeInteger,%) -> %
 construct : List(Record(k: S,c: R)) -> %
 constructOrdered : List(Record(k: S,c: R)) -> %
 leadingTerm : % -> Record(k: S,c: R)
 linearExtend : ((S -> R),%) -> R if R has COMRING
 listOfTerms : % -> List(Record(k: S,c: R))
 numberOfMonomials : % -> NonNegativeInteger
 retractIfCan : % -> Union(S,"failed")
 subtractIfCan : (%,%) -> Union(%,"failed")

See: [PolySpad]?

VectorSpace? --Bill Page, Thu, 10 Mar 2011 16:05:26 -0800 reply
A [FreeModule]? over a [Field]? is a VectorSpace? unfortunately this is not currently understood by Axiom:
axiom
FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)
\label{eq1} \mbox{\rm false} (1)
Type: Boolean

Ref: http://en.wikipedia.org/wiki/Vector_space#Modules

Add: 

        if R has Field then
             VectorSpace(R)

spad
)abbrev category FMCAT FreeModuleCategory
++ Author: Michel Petitot petitot@lifl.fr
++ Date Created: 91
++ Date Last Updated: 7 Juillet 92
++ Fix History: compilation v 2.1 le 13 dec 98
++ Basic Functions:
++ Related Constructors:
++ Also See:
++ AMS Classifications:
++ Keywords:
++ References:
++ Description:
++   A domain of this category
++   implements formal linear combinations
++   of elements from a domain \spad{Basis} with coefficients
++   in a domain \spad{R}. The domain \spad{Basis} needs only
++   to belong to the category \spadtype{SetCategory} and \spad{R}
++   to the category \spadtype{Ring}. Thus the coefficient ring
++   may be non-commutative.
++   See the \spadtype{XDistributedPolynomial} constructor
++   for examples of domains built with the \spadtype{FreeModuleCategory}
++   category constructor.
++   Author: Michel Petitot (petitot@lifl.fr)
++
++   Note (Franz Lehner, June 2009):
++   Since \spad{leadingTerm} makes no sense
++   for unordered base sets,
++   and at the time of this writing this domain was never used for such,
++   it was changed to \spad{OrderedSet}.
++   \spad{FreeModule} originally was not of FreeModuleCategory.
++   Some functions (like \spad{support}, \spad{coefficients},
++   \spad{monomials}, ...) from here could be moved to
++   \spad{IndexedDirectProductCategory}
++   but at the moment there is no need for this.
FreeModuleCategory(R, S):Category == Exports where
   R: Ring
   S: OrderedSet
   Term ==> Record(k: S, c: R)

   Exports == Join(BiModule(R,R), RetractableTo S, IndexedDirectProductCategory(R,S)) with
        "*"                : (R, S) -> %
          ++ \spad{r*b} returns the product of \spad{r} by \spad{b}.
        "*":(S,R) -> %
          ++ \spad{s*r} returns the product \spad{r*s}
          ++ used by \spadtype{XRecursivePolynomial}
        coefficients       : % -> List R
          ++ \spad{coefficients(x)} returns the list of coefficients of \spad{x}.
        support            : % -> List S
          ++ \spad{support(x)} returns the list of basis elements with nonzero coefficients.
        monomials          : % -> List %
          ++ \spad{monomials(x)} returns the list of \spad{r_i*b_i}
          ++ whose sum is \spad{x}.
        numberOfMonomials  : % -> NonNegativeInteger
          ++ \spad{numberOfMonomials(x)} returns the number of monomials of \spad{x}.
        monomial?: % -> Boolean
          ++ \spad{monomial?(x)} returns true if \spad{x} contains a single
          ++ monomial.
        leadingMonomial    : % -> S
          ++ \spad{leadingMonomial(x)} returns the first element from \spad{S}
          ++ which appears in \spad{listOfTerms(x)}.
        leadingCoefficient : % -> R
          ++ \spad{leadingCoefficient(x)} returns the first coefficient
          ++ which appears in \spad{listOfTerms(x)}.
        monom : (S, R) -> %
          ++ \spad{monom(s,r)} returns the product of the basis element \spad{s} by the coefficient \spad{r}.
        coefficient :(%,S) -> R
          ++ \spad{coefficient(x,s)} returns the coefficient of the basis element s
        -- attributes
        if R has Field then
             VectorSpace(R)
        if R has CommutativeRing then
             Module(R)
             linearExtend:(S->R,%)->R
          ++ \spad{linearExtend:(f,x)} returns the linear extension
          ++ of a map defined on the basis applied to a linear combination
        if R has Comparable then Comparable
      add
        if R has Comparable then
          smaller?(p:%,q:%):Boolean ==
            if leadingMonomial(p)=leadingMonomial(q) then
              if leadingCoefficient(p)=leadingCoefficient(q) then
                smaller?(reductum p, reductum q)
              else
                smaller?(leadingCoefficient(p),leadingCoefficient(q))
            leadingMonomial(p)<leadingMonomial(q)
spad
   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/2183133228744961848-25px003.spad using 
      old system compiler.
   FMCAT abbreviates category FreeModuleCategory 
   processing macro definition Term ==> Record(k: S,c: R) 
------------------------------------------------------------------------
   initializing NRLIB FMCAT for FreeModuleCategory 
   compiling into NRLIB FMCAT 

;;;     ***       |FreeModuleCategory| REDEFINED
Time: 0.36 SEC.

   FMCAT- abbreviates domain FreeModuleCategory& 
------------------------------------------------------------------------
   initializing NRLIB FMCAT- for FreeModuleCategory& 
   compiling into NRLIB FMCAT- 
****** Domain: R already in scope
augmenting R: (Comparable)
   compiling exported smaller? : (A,A) -> Boolean
Time: 0.52 SEC.

(time taken in buildFunctor:  0)

;;;     ***       |FreeModuleCategory&| REDEFINED
Time: 0 SEC.

   Cumulative Statistics for Constructor FreeModuleCategory&
      Time: 0.52 seconds

   finalizing NRLIB FMCAT- 
   Processing FreeModuleCategory& for Browser database:
--------(* (% R S))---------
--------(* (% S R))---------
--------(coefficients ((List R) %))---------
--------(support ((List S) %))---------
--------(monomials ((List %) %))---------
--------(numberOfMonomials ((NonNegativeInteger) %))---------
--------(monomial? ((Boolean) %))---------
--------(leadingMonomial (S %))---------
--------(leadingCoefficient (R %))---------
--------(monom (% S R))---------
--------(coefficient (R % S))---------
--->-->FreeModuleCategory&((linearExtend (R (Mapping R S) %))): Not documented!!!!
--------constructor---------
--------constructor---------
--->-->FreeModuleCategory&(): Spurious comments: \indented{1}{\spad{linearExtend:(f,{}x)} returns the linear extension} of a map defined on the basis applied to a linear combination
; compiling file "/var/zope2/var/LatexWiki/FMCAT-.NRLIB/FMCAT-.lsp" (written 10 MAR 2011 07:16:45 PM):
; compiling (/VERSIONCHECK 2)
; compiling (DEFUN |FMCAT-;smaller?;2AB;1| ...)
; compiling (DEFUN |FreeModuleCategory&| ...)
; compiling (MAKEPROP (QUOTE |FreeModuleCategory&|) ...)

; /var/zope2/var/LatexWiki/FMCAT-.NRLIB/FMCAT-.fasl written
; compilation finished in 0:00:00.306
------------------------------------------------------------------------
   FreeModuleCategory& is now explicitly exposed in frame initial 
   FreeModuleCategory& will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/FMCAT-.NRLIB/FMCAT-
   finalizing NRLIB FMCAT 
   Processing FreeModuleCategory for Browser database:
--------(* (% R S))---------
--------(* (% S R))---------
--------(coefficients ((List R) %))---------
--------(support ((List S) %))---------
--------(monomials ((List %) %))---------
--------(numberOfMonomials ((NonNegativeInteger) %))---------
--------(monomial? ((Boolean) %))---------
--------(leadingMonomial (S %))---------
--------(leadingCoefficient (R %))---------
--------(monom (% S R))---------
--------(coefficient (R % S))---------
--->/usr/local/lib/fricas/target/x86_64-unknown-linux/../../src/algebra/FMCAT.spad-->FreeModuleCategory((linearExtend (R (Mapping R S) %))): Not documented!!!!
--------constructor---------
--------constructor---------
--->/usr/local/lib/fricas/target/x86_64-unknown-linux/../../src/algebra/FMCAT.spad-->FreeModuleCategory(): Spurious comments: \indented{1}{\spad{linearExtend:(f,{}x)} returns the linear extension} of a map defined on the basis applied to a linear combination
; compiling file "/var/zope2/var/LatexWiki/FMCAT.NRLIB/FMCAT.lsp" (written 10 MAR 2011 07:16:44 PM):
; compiling (/VERSIONCHECK 2)
; compiling (DEFPARAMETER |FreeModuleCategory;CAT| ...)
; compiling (DEFPARAMETER |FreeModuleCategory;AL| ...)
; compiling (DEFUN |FreeModuleCategory| ...)
; compiling (DEFUN |FreeModuleCategory;| ...)

; /var/zope2/var/LatexWiki/FMCAT.NRLIB/FMCAT.fasl written
; compilation finished in 0:00:00.100
------------------------------------------------------------------------
   FreeModuleCategory is now explicitly exposed in frame initial 
   FreeModuleCategory will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/FMCAT.NRLIB/FMCAT

spad
)abbrev domain FM FreeModule
++ Author: Dave Barton, James Davenport, Barry Trager
++ Date Created:
++ Date Last Updated:
++ Basic Functions: BiModule(R,R)
++ Related Constructors:
++ Also See:
++ AMS Classifications:
++ Keywords:
++ References:
++ Description:
++ A bi-module is a free module
++ over a ring with generators indexed by an ordered set.
++ Each element can be expressed as a finite linear combination of
++ generators. Only non-zero terms are stored.

++ old domain FreeModule1 was merged to it in May 2009
++ The description of the latter:
++   This domain implements linear combinations
++   of elements from the domain \spad{S} with coefficients
++   in the domain \spad{R} where \spad{S} is an ordered set
++   and \spad{R} is a ring (which may be non-commutative).
++   This domain is used by domains of non-commutative algebra such as:
++       \spadtype{XDistributedPolynomial},
++       \spadtype{XRecursivePolynomial}.
++   Author: Michel Petitot (petitot@lifl.fr)

FreeModule(R:Ring,S:OrderedSet):
        Join(BiModule(R,R),FreeModuleCategory(R,S)) with
    if R has CommutativeRing then Module(R)
 == IndexedDirectProductAbelianGroup(R,S) add
    --representations
       Term ==>  Record(k:S,c:R)
       Rep :=  List Term
    --declarations
       x,y: %
       r: R
       n: Integer
       f: R -> R
       s: S
       lt: List Term
   --define
       if R has EntireRing then
         r * x  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x+->r*x1,x)
             [[u.k,r*u.c] for u in x ]
       else
         r * x  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x1+->r*x1,x)
             [[u.k,a] for u in x | (a:=r*u.c) ~= 0$R]
       if R has EntireRing then
         x * r  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x1+->r*x1,x)
             [[u.k,u.c*r] for u in x ]
       else
         x * r  ==
             zero? r => 0
--             one? r => x
             (r = 1) => x
           --map(x1+->r*x1,x)
             [[u.k,a] for u in x | (a:=u.c*r) ~= 0$R]

       r * s ==
         r = 0 => 0
         [[s,r]$Term]

       s * r ==
         r = 0 => 0
         [[s,r]$Term]

       coerce(x) : OutputForm ==
         null x => (0$R) :: OutputForm
         le : List OutputForm := nil
         for rec in reverse x repeat
           rec.c = 1 => le := cons(rec.k :: OutputForm, le)
           le := cons(rec.c :: OutputForm *  rec.k :: OutputForm, le)
         reduce("+",le)

       leadingMonomial x == x.first.k

       support x == [t.k for t in x]

       coefficients x == [t.c for t in x]

       monomials x == [ monom (t.k, t.c) for t in x]

       retractIfCan x ==
         numberOfMonomials(x) ~= 1 => "failed"
         x.first.c = 1 => x.first.k
         "failed"

       retract x ==
         (rr := retractIfCan x) case "failed" => error "FM1.retract impossible"
         rr :: S

       coerce(s:S):% == [[s,1$R]]

-- the following is to be replaced by monomial(r,b) everywhere
       monom(b,r):% == [[b,r]$Term]

       coefficient(x,s) ==
         null x => 0$R
         x.first.k > s => coefficient(rest x,s)
         x.first.k = s => x.first.c
         0$R

       monomial? x ==
         numberOfMonomials x = 1

       listOfTerms(x) ==
--          (x::Rep)
--          coerce(x)@Rep
         x pretend Rep

       numberOfMonomials x == # (listOfTerms x)

       if R has CommutativeRing then
           f:S->R
           x:%
           t:Term
           linearExtend(f,x) ==
               zero? x => 0
               res:R:= 0
               for t in listOfTerms x repeat
                   res := res + (t c)*f(t k)
               res
spad
   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/1868799774806656872-25px004.spad using 
      old system compiler.
   FM abbreviates domain FreeModule 
------------------------------------------------------------------------
   initializing NRLIB FM for FreeModule 
   compiling into NRLIB FM 
   processing macro definition Term ==> Record(k: S,c: R) 
****** Domain: R already in scope
augmenting R: (EntireRing)
   compiling exported * : (R,$) -> $

;;;     ***       |FM;*;R2$;1| REDEFINED
Time: 0.08 SEC.

   compiling exported * : (R,$) -> $

;;;     ***       |FM;*;R2$;2| REDEFINED
Time: 0.01 SEC.

****** Domain: R already in scope
augmenting R: (EntireRing)
   compiling exported * : ($,R) -> $

;;;     ***       |FM;*;$R$;3| REDEFINED
Time: 0.01 SEC.

   compiling exported * : ($,R) -> $

;;;     ***       |FM;*;$R$;4| REDEFINED
Time: 0.01 SEC.

   compiling exported * : (R,S) -> $

;;;     ***       |FM;*;RS$;5| REDEFINED
Time: 0 SEC.

   compiling exported * : (S,R) -> $

;;;     ***       |FM;*;SR$;6| REDEFINED
Time: 0.01 SEC.

   compiling exported coerce : $ -> OutputForm

;;;     ***       |FM;coerce;$Of;7| REDEFINED
Time: 0.09 SEC.

   compiling exported leadingMonomial : $ -> S

;;;     ***       |FM;leadingMonomial;$S;8| REDEFINED
Time: 0 SEC.

   compiling exported support : $ -> List S

;;;     ***       |FM;support;$L;9| REDEFINED
Time: 0.01 SEC.

   compiling exported coefficients : $ -> List R

;;;     ***       |FM;coefficients;$L;10| REDEFINED
Time: 0.06 SEC.

   compiling exported monomials : $ -> List $

;;;     ***       |FM;monomials;$L;11| REDEFINED
Time: 0.01 SEC.

   compiling exported retractIfCan : $ -> Union(S,failed)

;;;     ***       |FM;retractIfCan;$U;12| REDEFINED
Time: 0.01 SEC.

   compiling exported retract : $ -> S

;;;     ***       |FM;retract;$S;13| REDEFINED
Time: 0 SEC.

   compiling exported coerce : S -> $

;;;     ***       |FM;coerce;S$;14| REDEFINED
Time: 0 SEC.

   compiling exported monom : (S,R) -> $

;;;     ***       |FM;monom;SR$;15| REDEFINED
Time: 0 SEC.

   compiling exported coefficient : ($,S) -> R

;;;     ***       |FM;coefficient;$SR;16| REDEFINED
Time: 0 SEC.

   compiling exported monomial? : $ -> Boolean

;;;     ***       |FM;monomial?;$B;17| REDEFINED
Time: 0 SEC.

   compiling exported listOfTerms : $ -> List Record(k: S,c: R)
      FM;listOfTerms;$L;18 is replaced by x 

;;;     ***       |FM;listOfTerms;$L;18| REDEFINED
Time: 0 SEC.

   compiling exported numberOfMonomials : $ -> NonNegativeInteger

;;;     ***       |FM;numberOfMonomials;$Nni;19| REDEFINED
Time: 0 SEC.

****** Domain: R already in scope
augmenting R: (CommutativeRing)
   compiling exported linearExtend : (S -> R,$) -> R

;;;     ***       |FM;linearExtend;M$R;20| REDEFINED
Time: 0 SEC.

****** Domain: R already in scope
augmenting R: (CommutativeRing)
****** Domain: R already in scope
augmenting R: (Comparable)
****** Domain: R already in scope
augmenting R: (Field)
(time taken in buildFunctor:  20)

;;;     ***       |FreeModule| REDEFINED

;;;     ***       |FreeModule| REDEFINED
Time: 0.03 SEC.

   Warnings: 
      [1] listOfTerms: pretendRep -- should replace by @

   Cumulative Statistics for Constructor FreeModule
      Time: 0.33 seconds

   finalizing NRLIB FM 
   Processing FreeModule for Browser database:
--------constructor---------
; compiling file "/var/zope2/var/LatexWiki/FM.NRLIB/FM.lsp" (written 10 MAR 2011 07:16:59 PM):
; compiling (/VERSIONCHECK 2)
; compiling (DEFUN |FM;*;R2$;1| ...)
; compiling (DEFUN |FM;*;R2$;2| ...)
; compiling (DEFUN |FM;*;$R$;3| ...)
; compiling (DEFUN |FM;*;$R$;4| ...)
; compiling (DEFUN |FM;*;RS$;5| ...)
; compiling (DEFUN |FM;*;SR$;6| ...)
; compiling (DEFUN |FM;coerce;$Of;7| ...)
; compiling (DEFUN |FM;leadingMonomial;$S;8| ...)
; compiling (DEFUN |FM;support;$L;9| ...)
; compiling (DEFUN |FM;coefficients;$L;10| ...)
; compiling (DEFUN |FM;monomials;$L;11| ...)
; compiling (DEFUN |FM;retractIfCan;$U;12| ...)
; compiling (DEFUN |FM;retract;$S;13| ...)
; compiling (DEFUN |FM;coerce;S$;14| ...)
; compiling (DEFUN |FM;monom;SR$;15| ...)
; compiling (DEFUN |FM;coefficient;$SR;16| ...)
; compiling (DEFUN |FM;monomial?;$B;17| ...)
; compiling (PUT (QUOTE |FM;listOfTerms;$L;18|) ...)
; compiling (DEFUN |FM;listOfTerms;$L;18| ...)
; compiling (DEFUN |FM;numberOfMonomials;$Nni;19| ...)
; compiling (DEFUN |FM;linearExtend;M$R;20| ...)
; compiling (DEFUN |FreeModule| ...)
; compiling (DEFUN |FreeModule;| ...)
; compiling (MAKEPROP (QUOTE |FreeModule|) ...)

; /var/zope2/var/LatexWiki/FM.NRLIB/FM.fasl written
; compilation finished in 0:00:00.810
------------------------------------------------------------------------
   FreeModule is now explicitly exposed in frame initial 
   FreeModule will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/FM.NRLIB/FM

axiom
FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)
\label{eq2} \mbox{\rm true} (2)
Type: Boolean