Edit detail for SandBoxHopfAlgebra revision 4 of 6

On Fri, May 15, 2009 at 03:23:33AM +0200, Franz Lehner wrote:

Now it more or less works, included is a first example of a bialgebra (just too lazy to write up the antipode):

)library TENSORC TENSORP TENSORD

   TensorProductCategory is now explicitly exposed in frame initial
   TensorProductCategory will be automatically loaded when needed from
      /var/zope2/var/LatexWiki/TENSORC.NRLIB/TENSORC
   TensorProductProperty is now explicitly exposed in frame initial
   TensorProductProperty will be automatically loaded when needed from
      /var/zope2/var/LatexWiki/TENSORP.NRLIB/TENSORP
   TensorProduct is now explicitly exposed in frame initial
   TensorProduct will be automatically loaded when needed from
      /var/zope2/var/LatexWiki/TENSORD.NRLIB/TENSORD

)abbrev category COALG CoAlgebra
CoAlgebra(R : CommutativeRing, RR : TensorProductCategory(R, %, %)) : Category == _
        Module(R) with
    Delta : % -> RR
       ++ delta is comultiplication
    counit: % -> R
       ++ counit
)abbrev category BIALG BiAlgebra
BiAlgebra(R : CommutativeRing, RR : TensorProductCategory(R, %, %)) : Category == _
     Join(Algebra(R), CoAlgebra(R, RR))
)abbrev category HOPFALG HopfAlgebra
HopfAlgebra(R : CommutativeRing, RR : TensorProductCategory(R, %, %)) : Category _
     == BiAlgebra(R, RR) with
    S : % -> %
       ++ the antipode
)abbrev domain PHALG PolyHopfAlgebra
PolyHopfAlgebra(R: CommutativeRing,x: Symbol): C == T where
    S == Variable x
    FM == FreeMonoid Symbol
    PxP == TensorProduct(R, FM, FM, %, %) 
--    C == Join(FreeModule(R, FM),HopfAlgebra(R, PxP))
    C == Join(UnivariatePolynomialCategory(R), _
         FreeModuleCat(R, FM), BiAlgebra(R, PxP))

    TERM == Record(k: FM,c: R)

    T == SparseUnivariatePolynomial(R) add
           Rep:= SparseUnivariatePolynomial(R) 

           monom(a:FM,r:R):% == 
                one? a => monomial(r, 0@NonNegativeInteger)
                monomial(r, nthExpon(a, 1@Integer))

--           monomial(r:R, n:NonNegativeInteger) == monomial(r,n)@Rep

           coerce(p:%):OutputForm == outputForm(p,outputForm x)$Rep

           Delta1(n:NonNegativeInteger):PxP == 
                res: PxP := 0
                nn:List NonNegativeInteger := [k for k in 0..n]
                for k1 in nn for k2 in reverse nn repeat
                     res:= res + binomial(n,k1)*product(monomial(1@R,k1),monomial(1@R,k2))$PxP
                res

           ListOfTerms(p:%):List TERM ==
               res:List TERM := []
               while not zero? p repeat
                  m:FM := (variable()$S)**degree p
                  m1:TERM := [m,leadingCoefficient p]
                  res:=concat!(res, m1)
                  p:=reductum p
               res

           Delta(p:%):PxP == 
                zero? p => 0
                lt:R := leadingCoefficient p
                lt * Delta1(degree p) + Delta reductum p

           counit(p:%):R == coefficient(p,0)

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/8300278871242681918-25px002.spad using 
      old system compiler.
   COALG abbreviates category CoAlgebra 
------------------------------------------------------------------------
   initializing NRLIB COALG for CoAlgebra 
   compiling into NRLIB COALG 

;;;     ***       |CoAlgebra| REDEFINED
Time: 0.05 SEC.

   finalizing NRLIB COALG 
   Processing CoAlgebra for Browser database:
--------(Delta (RR %))---------
--------(counit (R %))---------
--->-->CoAlgebra(constructor): Not documented!!!!
--->-->CoAlgebra(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/COALG.NRLIB/COALG.lsp" (written 12 OCT 2009 12:26:10 AM):
; compiling (/VERSIONCHECK 2)
; compiling (DEFPARAMETER |CoAlgebra;CAT| ...)
; compiling (DEFPARAMETER |CoAlgebra;AL| ...)
; compiling (DEFUN |CoAlgebra| ...)
; compiling (DEFUN |CoAlgebra;| ...)

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

   BIALG abbreviates category BiAlgebra 
------------------------------------------------------------------------
   initializing NRLIB BIALG for BiAlgebra 
   compiling into NRLIB BIALG 

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

   finalizing NRLIB BIALG 
   Processing BiAlgebra for Browser database:
--->-->BiAlgebra(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/BIALG.NRLIB/BIALG.lsp" (written 12 OCT 2009 12:26:10 AM):
; compiling (/VERSIONCHECK 2)
; compiling (DEFPARAMETER |BiAlgebra;CAT| ...)
; compiling (DEFPARAMETER |BiAlgebra;AL| ...)
; compiling (DEFUN |BiAlgebra| ...)
; compiling (DEFUN |BiAlgebra;| ...)

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

   HOPFALG abbreviates category HopfAlgebra 
------------------------------------------------------------------------
   initializing NRLIB HOPFALG for HopfAlgebra 
   compiling into NRLIB HOPFALG 

;;;     ***       |HopfAlgebra| REDEFINED
Time: 0.04 SEC.

   finalizing NRLIB HOPFALG 
   Processing HopfAlgebra for Browser database:
--------(S (% %))---------
--->-->HopfAlgebra(constructor): Not documented!!!!
--->-->HopfAlgebra(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/HOPFALG.NRLIB/HOPFALG.lsp" (written 12 OCT 2009 12:26:10 AM):
; compiling (/VERSIONCHECK 2)
; compiling (DEFPARAMETER |HopfAlgebra;CAT| ...)
; compiling (DEFPARAMETER |HopfAlgebra;AL| ...)
; compiling (DEFUN |HopfAlgebra| ...)
; compiling (DEFUN |HopfAlgebra;| ...)

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

   PHALG abbreviates domain PolyHopfAlgebra 
------------------------------------------------------------------------
   initializing NRLIB PHALG for PolyHopfAlgebra 
   compiling into NRLIB PHALG 
****** comp fails at level 1 with expression: ******
((|FreeModuleCat| R (|FreeMonoid| (|Symbol|))))
****** level 1  ******
$x:= (FreeModuleCat R (FreeMonoid (Symbol)))
$m:= $EmptyMode
$f:=
((((|x| # #) (R # #) (|PolyHopfAlgebra| #) (R #) ...)))

   >> Apparent user error:
   cannot compile (FreeModuleCat R (FreeMonoid (Symbol)))

P:=PolyHopfAlgebra(Integer,'u)

   PolyHopfAlgebra is an unknown constructor and so is unavailable. Did
      you mean to use -> but type something different instead?
p:=monomial(1,1)$P

   The function monomial is not implemented in NIL .
Delta p

   There are 1 exposed and 0 unexposed library operations named Delta
      having 1 argument(s) but none was determined to be applicable.
      Use HyperDoc Browse, or issue
                              )display op Delta
      to learn more about the available operations. Perhaps
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named Delta
      with argument type(s)
                                 Variable(p)

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.
Delta(p^2)

   There are 1 exposed and 0 unexposed library operations named Delta
      having 1 argument(s) but none was determined to be applicable.
      Use HyperDoc Browse, or issue
                              )display op Delta
      to learn more about the available operations. Perhaps
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named Delta
      with argument type(s)
                             Polynomial(Integer)

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.
Delta(p)^2

   There are 1 exposed and 0 unexposed library operations named Delta
      having 1 argument(s) but none was determined to be applicable.
      Use HyperDoc Browse, or issue
                              )display op Delta
      to learn more about the available operations. Perhaps
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named Delta
      with argument type(s)
                                 Variable(p)

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.
q:=p+3

(1)

Delta(q^2)

   There are 1 exposed and 0 unexposed library operations named Delta
      having 1 argument(s) but none was determined to be applicable.
      Use HyperDoc Browse, or issue
                              )display op Delta
      to learn more about the available operations. Perhaps
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named Delta
      with argument type(s)
                             Polynomial(Integer)

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.

Please comment.

Next comes the old problem come with iterated structures. Is it in principle possible to have:

  TensorProduct(R:CommutativeRing,LB:List OrderedSet, LM:List FreeModuleCat(R))?

Since the coproduct is coassociative, we might want to define "powers", but I realize that tensor powers are actually feasible.

Actually the basis is not redundant; in the attached example the implementation of the Coalgebra does not use the basis which it pretends to the tensor product. Still exporting a basis would be a nice thing.

More questions:

1. How far are we from having unicode in output?
2. CoAlgebra? or Coalgebra?
3. Delta or coproduct? epsilon or counit? S or antipode? or both?
4. I do not see which domains should use TensorProductProperty?, the target module S is not part of the domain. Anyways morphisms have to be implemented in packages ("TensorProductFunctions2?" or something like that)
5. For now TensorProduct? relies on FreeModuleCat?. To make use of the existing applicable domains we have to add FreeModuleCat? everywhere. Extend would be good ... First of course comes a cleanup of FreeModule? itself. The example I cooked up in the attachment is rather ugly and fragile.
6. The compiler does not warn about missing exports. (this is a really nice feature of the aldor compiler) I can add all categories I like, they pass the compiler and )sh domain shows all the operations exported by the categories. The only way to detect missing ones is by runtime errors.
7. ceterum censeo Aldorem esse liberandam (ok, that suffices for now)