#18350: Adams operator
-------------------------------------+-------------------------------------
Reporter: elixyre | Owner:
Type: task | Status: needs_review
Priority: major | Milestone: sage-6.7
Component: categories | Resolution:
Keywords: | Merged in:
Authors: Jean-Baptiste | Reviewers:
Priez | Work issues:
Report Upstream: N/A | Commit:
Branch: | fc8726a50725479d84aa9a07f55e28e1f879880a
u/elixyre/ticket/18350 | Stopgaps:
Dependencies: |
-------------------------------------+-------------------------------------
Changes (by nthiery):
* cc: nborie, mshimo (added)
Comment:
Salut Jean-Baptiste,
Thanks for the proof of concept!
Computing `n`-fold products and coproducts is a generally useful
feature, so I would abstract it away. Probably with an API such as:
{{{
sage: H = MyFavoriteHopfAlgebra()
sage: coprodk = H.nfold_coproduct(n); phi
A morphism from H to H # ... # H
sage: muk = H.mu(n); muk
A morphism from H # ... # H to H
sage: mu = H.mu(); mu # default value
A morphism from H # H to H
sage: adams = H.adams_operator(n); adams
A morphism from H to H
}}}
I don't have a strong opinion for what `n` should stand for. At first
sight it feels natural to have `H.nfold_coproduct(n)` go from `H` the
`n`-fold tensor product of `H`, and reciprocally for `H.mu`. But this
does not match with Dima's suggestion since `H.coproduct` would be
`H.nfold_coproduct(2)`.
Possibly with shorthands to call those from the elements:
{{{
sage: h = H().an_element()
sage: h.nfold_coproduct(n) # in
Coalgebras.TensorProducts.ElementMethods
sage: h.adams(n) # in
HopfAlgebras.TensorProducts.ElementMethods?
sage: tensor([h,h,h]).mu() # in
Algebras.TensorProducts.ElementMethods?
}}}
This approach also has the advantage of constructing the morphisms
only once.
`H.adams_operator` can be simply defined as `H.mu(n) *
H.nfold_coproduct(n)`. `H.mu` can be defined straightforwardly on the
basis. `H.nfold_coproduct` indeed has to be defined recursively as
you did. We might as well use binary exponentiation. For example,
`H.nfold_coproduct(2*n)` can be defined as:
{{{
tensor([H.coproduct(n), H.coproduct(n)]) * H.coproduct
}}}
So altogether this should require no more code (possibly less) than
what you have already.
One small feature we are missing in Sage 6.6: constructing tensor
products of morphisms. Luckily we do have code for this: #15832
(Nicolas Borie also has code for this somewhere; Nicolas: could you
provide us with a pointer? Thanks). It's a small feature that we
really want to have anyway, so that can be a good occasion to get it
merged in.
Cheers,
Nicolas
--
Ticket URL: <http://trac.sagemath.org/ticket/18350#comment:6>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.
