#10305: Add rings for the center of the symmetric group algebras
-------------------------------------+-------------------------------------
       Reporter:  mguaypaq           |        Owner:  mguaypaq
           Type:  enhancement        |       Status:  needs_work
       Priority:  minor              |    Milestone:  sage-5.12
      Component:  combinatorics      |   Resolution:
       Keywords:  combinatorics,     |    Merged in:
  rings, symmetric functions         |    Reviewers:  Travis Scrimshaw,
        Authors:  Mathieu Guay-      |  Mathieu Guay-Paquet
  Paquet, Travis Scrimshaw           |  Work issues:
Report Upstream:  N/A                |       Commit:
         Branch:                     |     Stopgaps:
   Dependencies:                     |
-------------------------------------+-------------------------------------
Changes (by {'newvalue': u'Mathieu Guay-Paquet, Travis Scrimshaw', 'oldvalue': 
u'Mathieu Guay-Paquet'}):

 * reviewer:   => Travis Scrimshaw, Mathieu Guay-Paquet
 * author:  Mathieu Guay-Paquet => Mathieu Guay-Paquet, Travis Scrimshaw


Old description:

> Here is some preliminary code to implement the center of the symmetric
> group algebras, various bases for this and related rings, and coercions
> between these and to/from the ring of symmetric functions.
>
> Things that I plan to do:
>  * Fill in all of the TODO doctests with actual doctests.
>  * Figure out why some of the coercions aren't discovered by the coercion
> framework. (See the last few examples at the top of the file.)
>  * `SymmetricGroupAlgebraCenter` does not actually have a multiplicative
> identity as currently implemented, so it should probably by in a category
> other than `GradedAlgebrasWithBasis`.
>  * Reimplement `ConjugacyClassBasis` and `OrthogonalIdempotentBasis` for
> a fixed symmetric group over the integers. Then, the conversion table can
> be cached, the elements can be represented by lists of coefficients
> (possibly numpy arrays) instead of dictionaries, and faster linear
> algebra over the integers can be used. This results in massive (several
> orders of magnitude) speedups.
>  * Possibly add the option of saving some of the conversion tables to
> disk, as they can be large and expensive to compute.
>  * Add the relevant classes to `sage/combinat/all.py`.
>
> Note that this depends on #7980 and #10304.

New description:

 Here is some preliminary code to implement the center of the symmetric
 group algebras, various bases for this and related rings, and coercions
 between these and to/from the ring of symmetric functions.

 Things that I plan to do:
  * Fill in all of the TODO doctests with actual doctests.
  * Figure out why some of the coercions aren't discovered by the coercion
 framework. (See the last few examples at the top of the file.)
  * `SymmetricGroupAlgebraCenter` does not actually have a multiplicative
 identity as currently implemented, so it should probably by in a category
 other than `GradedAlgebrasWithBasis`.
  * Reimplement `ConjugacyClassBasis` and `OrthogonalIdempotentBasis` for a
 fixed symmetric group over the integers. Then, the conversion table can be
 cached, the elements can be represented by lists of coefficients (possibly
 numpy arrays) instead of dictionaries, and faster linear algebra over the
 integers can be used. This results in massive (several orders of
 magnitude) speedups.
  * Possibly add the option of saving some of the conversion tables to
 disk, as they can be large and expensive to compute.
  * Add the relevant classes to `sage/combinat/all.py`.

 Note that this depends on #7980 and #10304.

 Apply:

 [attachment:trac_10305-farahat_higman-ts.patch]

--

Comment:

 Hey Matthieu,

 Here's everything that I could do with the patch. I've reworked it to use
 the same framework as the symmetric functions, allowed the SGA center for
 a fixed n, and added in coercions to the SGA when appropriate. However
 there's three more things I'll need from you:

 - Could you put in some references for the Farahat-Higman/partial class
 algebras?
 - From what I could find, it seems like the Farahat-Higman algebra is
 actually just the parts for a fixed `n`, not allowing `n` to vary. Thus we
 would need to take the terms just corresponding to partitions `n` in the
 larger product. Is this correct?
 - On line 426 of `farahat_higman.py`, you had originally left that
 sentence as incomplete and I couldn't figure out how to finish it. Could
 you finish writing that paragraph?

 (Due to the amount of changes by just reorganizing code, I felt it was
 better to post a new version of the patch than a review patch.)

 For reviewing this patch, we'll do a cross-review where I review your
 changes and you review mine. Sound good?

 Thanks,[[BR]]
 Travis

 For patchbot:

 Apply: trac_10305-farahat_higman-ts.patch

--
Ticket URL: <http://trac.sagemath.org/ticket/10305#comment:11>
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/groups/opt_out.

Reply via email to