Edit detail for FreeModule revision 6 of 8

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
\begin{axiom}
)sh FreeModule
\end{axiom}
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:
\begin{axiom}
FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)
\end{axiom}

Ref: http://en.wikipedia.org/wiki/Vector_space#Modules
Add:
        if R has Field then VectorSpace(R)
        ...
        if R has Field then
          if S has Finite then
            dimension():CardinalNumber == coerce size()$S
          else
             dimension():CardinalNumber == Aleph(0)


\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{rb} returns the product of \spad{r} by \spad{b}.
        "":(S,R) -> %
          ++ \spad{sr} returns the product \spad{rs}
          ++ 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_ib_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 Field then
          if S has Finite then
            dimension():CardinalNumber? == coerce size()$S
          else
             dimension():CardinalNumber? == Aleph(0)
        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)

\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+->rx1,x)
             [[u.k,ru.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:=ru.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.cr] 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}
F2:=FreeModule?(Fraction Integer,OrderedVariableList? [e1,e1]?)
F2 has VectorSpace?(Fraction Integer)
dimension()$F2
\end{axiom}


    Some or all expressions may not have rendered properly,
    because Axiom returned the following error:
Error: export HOME=/var/zope2/var/LatexWiki; ulimit -t 600; export LD_LIBRARY_PATH=/usr/local/lib/fricas/target/x86_64-linux-gnu/lib; LANG=en_US.UTF-8 /usr/local/lib/fricas/target/x86_64-linux-gnu/bin/fricas -nosman < /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/895847409844110968-25px.axm
WARNING: redefining BOOT::|FreeModuleCategory| in DEFUN

debugger invoked on a SIMPLE-CONDITION in thread
#<THREAD "main thread" RUNNING {1001940003}>:
  break
Checking for foreign routines
FRICAS="/usr/local/lib/fricas/target/x86_64-linux-gnu"
spad-lib="/usr/local/lib/fricas/target/x86_64-linux-gnu/lib/libspad.so"
foreign routines found
openServer result -2
                       FriCAS Computer Algebra System 
             Version: FriCAS 1.4.0 built with sbcl 2.2.9.debian
                  Timestamp: Fri 16 Oct 16:10:51 CEST 2026
-----------------------------------------------------------------------------
   Issue )copyright to view copyright notices.
   Issue )summary for a summary of useful system commands.
   Issue )quit to leave FriCAS and return to shell.
-----------------------------------------------------------------------------
(1) -> (1) -> (1) -> (1) -> (1) -> (1) -> )sh FreeModule
 FreeModule(R: Join(SemiRng,AbelianMonoid),S: SetCategory) is a domain constructor
 Abbreviation for FreeModule is FM 
 This constructor is not exposed in this frame.
------------------------------- Operations --------------------------------
 ?? : (S, R) -> %                     ?? : (R, S) -> %
 ?? : (%, R) -> %                     ?? : (R, %) -> %
 ?? : (PositiveInteger, %) -> %       ?+? : (%, %) -> %
 -? : % -> % if R has ABELGRP          ?=? : (%, %) -> Boolean
 coefficient : (%, S) -> R             coefficients : % -> List(R)
 coerce : % -> OutputForm              latex : % -> String
 map : ((R -> R), %) -> %              monomial : (R, S) -> %
 monomial? : % -> Boolean              monomials : % -> List(%)
 support : % -> List(S)                ?~=? : (%, %) -> Boolean
 ?? : (Integer, %) -> % if R has ABELGRP
 ?*? : (NonNegativeInteger, %) -> % if R has ABELMON or R has OAMONS and S has ORDSET
 ?-? : (%, %) -> % if R has ABELGRP
 0 : () -> % if R has ABELMON or R has OAMONS and S has ORDSET
 ?<? : (%, %) -> Boolean if R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 ?<=? : (%, %) -> Boolean if R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 ?>? : (%, %) -> Boolean if R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 ?>=? : (%, %) -> Boolean if R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 abs : % -> % if % has ABELGRP and R has OAMONS and S has ORDSET or % has ABELGRP and R has OASGP and S has ORDSET
 coerce : S -> % if R has SRING
 construct : List(Record(k: S,c: R)) -> %
 constructOrdered : List(Record(k: S,c: R)) -> % if S has COMPAR
 hash : % -> SingleInteger if R has HASHABL and S has HASHABL
 hashUpdate! : (HashState, %) -> HashState if R has HASHABL and S has HASHABL
 inf : (%, %) -> % if R has OAMONS and S has ORDSET
 leadingCoefficient : % -> R if S has COMPAR
 leadingMonomial : % -> % if S has COMPAR
 leadingSupport : % -> S if S has COMPAR
 leadingTerm : % -> Record(k: S,c: R) if S has COMPAR
 linearExtend : ((S -> R), %) -> R if R has COMRING
 listOfTerms : % -> List(Record(k: S,c: R))
 max : (%, %) -> % if R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 min : (%, %) -> % if R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 negative? : % -> Boolean if % has SETCATZ and R has OAMONS and S has ORDSET or % has SETCATZ and R has OASGP and S has ORDSET
 numberOfMonomials : % -> NonNegativeInteger
 opposite? : (%, %) -> Boolean if R has ABELMON or R has OAMONS and S has ORDSET
 positive? : % -> Boolean if % has SETCATZ and R has OAMONS and S has ORDSET or % has SETCATZ and R has OASGP and S has ORDSET
 reductum : % -> % if S has COMPAR
 retract : % -> S if R has SRING
 retractIfCan : % -> Union(S,"failed") if R has SRING
 sample : () -> % if R has ABELMON or R has OAMONS and S has ORDSET
 sign : % -> Integer if % has SETCATZ and R has OAMONS and S has ORDSET or % has SETCATZ and R has OASGP and S has ORDSET
 smaller? : (%, %) -> Boolean if R has COMPAR and S has COMPAR or R has OAMONS and S has ORDSET or R has OASGP and S has ORDSET
 subtractIfCan : (%, %) -> Union(%,"failed") if R has ABELGRP or R has CABMON or R has OAMONS and S has ORDSET
 sup : (%, %) -> % if R has OAMONS and S has ORDSET
 zero? : % -> Boolean if R has ABELMON or R has OAMONS and S has ORDSET
(1) -> FreeModule(Fraction Integer,OrderedVariableList [e1,e1]) has VectorSpace(Fraction Integer)
   There are no library operations named VectorSpace 
      Use HyperDoc Browse or issue
                            )what op VectorSpace
      to learn if there is any operation containing " VectorSpace " in 
      its name.
   Cannot find a definition or applicable library operation named 
      VectorSpace with argument type(s) 
                                    Type
      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

(1) -> <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{rb} returns the product of \spad{r} by \spad{b}.
        "":(S,R) -> %
          ++ \spad{sr} returns the product \spad{rs}
          ++ 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_ib_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 Field then
          if S has Finite then
            dimension():CardinalNumber == coerce size()$S
          else
             dimension():CardinalNumber == Aleph(0)
        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/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/5194433629109442357-25px003.spad
      using system compiler.
   FMCAT abbreviates category FreeModuleCategory 
------------------------------------------------------------------------
   initializing NRLIB FMCAT for FreeModuleCategory 
   compiling into NRLIB FMCAT 

;;;     ***       |FreeModuleCategory| REDEFINED
Time: 0.01 SEC.
Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.
restarts (invokable by number or by possibly-abbreviated name):
  0: [CONTINUE] Return from BREAK.
  1: [ABORT   ] Exit from the current thread.
(|JoinInner| (#((|BiModule| |t#1| |t#1|) ((( #) T (ELT % 6)) (( #) (OR # #1=#) (ELT % 6)) ((- #) (OR # #1#) (ELT % 6)) ((- #) (OR # #1#) (ELT % 6)) ((|subtractIfCan| #) (OR # #1#) (ELT % 6)) ((|opposite?| #) (OR # #2=#) (ELT % 6)) (( #) (OR # #2#) (ELT % 6)) ((|0| #3=#) (OR # #2#) (CONST % 6)) ((|sample| #3#) (OR # #2#) (CONST % 6)) ((|zero?| #) (OR # #2#) (ELT % 6)) (( #) T (ELT % 6)) (( #) T (ELT % 6)) ...) NIL (|Category|) (((|LeftModule| |t#1|) (|AbelianSemiGroup|) (|SetCategory|) (|BasicType|)) ((#4=# #) (#5=# #) (#6=# #) (# T) (# T)) NIL) NIL) #((|RetractableTo| |t#2|) (((|retract| #) T (ELT % 6)) ((|retractIfCan| #) T (ELT % 6)) ((|coerce| #) T (ELT % 6))) NIL (|Category|) (((|CoercibleFrom| |t#2|)) NIL NIL) NIL) #((|IndexedDirectProductCategory| |t#1| |t#2|) (((~= #7=#) (OR #8=# #9=#) (ELT % 6)) ((= #7#) (OR #8# #9#) (ELT % 6)) ((|coerce| #) (OR #8# #9#) (ELT % 6)) ((|latex| #) (OR #8# #9#) (ELT % 6)) ((|smaller?| #) #8# (ELT % 6)) ((|numberOfMonomials| #) T (ELT % 6)) ((|listOfTerms| #) T (ELT % 6)) ((|leadingTerm| #) #10=(|has| |t#2| #) (ELT % 6)) ((|constructOrdered| #) #10# (ELT % 6)) ((|reductum| #) #10# (ELT % 6)) ((|leadingSupport| #) #10# (ELT % 6)) ((|leadingCoefficient| #) #10# (ELT % 6)) ...) NIL (|Category|) (((|IndexedProductCategory| |t#1| |t#2|) (|AbelianProductCategory| |t#1|)) ((# #) (# #) (#4# #9#) (# #) (#5# #9#) (#6# #)) NIL) NIL) #(NIL ((( #) T (ELT % 6)) ((* #) T (ELT % 6)) ((|coefficients| #) T (ELT % 6)) ((|support| #) T (ELT % 6)) ((|monomials| #) T (ELT % 6)) ((|numberOfMonomials| #) T (ELT % 6)) ((|monomial?| #) T (ELT % 6)) ((|leadingMonomial| #) T (ELT % 6)) ((|leadingCoefficient| #) T (ELT % 6)) ((|monom| #) T (ELT % 6)) ((|coefficient| #) T (ELT % 6)) ((|linearExtend| #) (|has| |t#1| #) (ELT % 6))) (((|VectorSpace| |t#1|) (|has| |t#1| #)) ((|Module| |t#1|) (|has| |t#1| #)) ((|Comparable|) (|has| |t#1| #))) (|Category|) (NIL NIL NIL) NIL)))
   error finding frame source: Bogus form-number: the source file has probably
                               changed too much to cope with.
   source: NIL
0] 

! Undefined control sequence.
l.145 ++   to belong to the category \spadtype
                                              {SetCategory} and \spad{R}
 Undefined control sequence.
l.146 ++   to the category \spadtype
                                    {Ring}. Thus the coefficient ring
 Undefined control sequence.
l.148 ++   See the \spadtype
                            {XDistributedPolynomial} constructor
 Undefined control sequence.
l.149 ...mples of domains built with the \spadtype
                                                  {FreeModuleCategory}
 Undefined control sequence.
l.173           ++ used by \spadtype
                                    {XRecursivePolynomial}
 Missing $ inserted.
<inserted text> 
                $
l.179 ...onomials(x)} returns the list of \spad{r_
                                                  i*b_i}
(/usr/share/texlive/texmf-dist/tex/latex/jknapltx/ursfs.fd)
(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/umsa.fd)
(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/umsb.fd)
 Extra }, or forgotten $.
l.179 ...ls(x)} returns the list of \spad{r_i*b_i}
 Missing } inserted.
<inserted text> 
                }
l.218 \end{spad}
                \newpage

Overfull \hbox (86.02371pt too wide) in paragraph at lines 168--218
\OT1/cmr/m/n/12 +\OML/cmm/m/it/12 whichappearsin[]:leadingCoefficient \OT1/cmr/
m/n/12 : + + []\OML/cmm/m/it/12 returnsthefirstcoefficient \OT1/cmr/m/n/12 + +\
OML/cmm/m/it/12 whichappearsin[]:monom \OT1/cmr/m/n/12 :
Overfull \hbox (118.38922pt too wide) in paragraph at lines 168--218
\OT1/cmr/m/n/12 (\OML/cmm/m/it/12 S; R\OT1/cmr/m/n/12 )\OMS/cmsy/m/n/12 ^^@ \OM
L/cmm/m/it/12 > \OT1/cmr/m/n/12 + + []\OML/cmm/m/it/12 returnstheproductoftheba
siselementsbythecoefficientr:coefficient \OT1/cmr/m/n/12 : (+ + []\OML/cmm/m/it
/12 returnsthecoefficientofthebasiselements \OMS/cmsy/m/n/12 ^^@
Overfull \hbox (139.80635pt too wide) in paragraph at lines 168--218
\OMS/cmsy/m/n/12 ^^@\OML/cmm/m/it/12 attributesifRhasFieldthenVectorSpace\OT1/c
mr/m/n/12 (\OML/cmm/m/it/12 R\OT1/cmr/m/n/12 )\OML/cmm/m/it/12 ifRhasCommutativ
eRingthenModule\OT1/cmr/m/n/12 (\OML/cmm/m/it/12 R\OT1/cmr/m/n/12 )\OML/cmm/m/i
t/12 linearExtend \OT1/cmr/m/n/12 : (\OML/cmm/m/it/12 S\OMS/cmsy/m/n/12 ^^@ \OM
L/cmm/m/it/12 > R; \OT1/cmr/m/n/12 + + []\OML/cmm/m/it/12 returnsthelinearexten
sion \OT1/cmr/m/n/12 +
Overfull \hbox (36.92639pt too wide) in paragraph at lines 168--218
\OT1/cmr/m/n/12 +\OML/cmm/m/it/12 ofamapdefinedonthebasisappliedtoalinearcombin
ationifRhasComparablethenComparableaddifRhasFieldthenifShasFinitethendimension\
OT1/cmr/m/n/12 () :
Overfull \hbox (178.36586pt too wide) in paragraph at lines 168--218
\T1/cmr/m/n/12 mial(p)=leadingMonomial(q) then if lead-ing-Co-ef-fi-cient(p)=le
adingCoefficient(q) then smaller?(reductum p, re-duc-tum q) else smaller?