Implement plethysm of tensors of symmetric functions

[zabrocki]

Currently plethsym of symmetric functions f(g) where both f and g are symmetric functions is implemented. This ticket would add the feature to allow g to be a tensor of symmetric functions.

If X = tensor([s[1],s[[]]]) and Y = tensor([s[[]], s[1]]) then f(X+Y) and f(X*Y) make sense and follow the notation found in mathematical papers that use plethystic notation.

[zabrocki]

Here is a first implementation

---

New commits:

​575c455

implement plethysm of tensor and example

[mantepse]

Hi Mike!

I attached some code for working with symmetric functions in several alphabets, including the plethysm of an ordinary and a multivariate symmetric function as well as the plethysm of a multivariate and an ordinary symmetric function. It is by no means polished, but maybe you can use it anyway.

[git]

Branch pushed to git repo; I updated commit sha1. New commits:

​b545dcb	Merge branch 'develop' into public/pleth_tensor/23446
​2e652ee	move functions within plethysm

[zabrocki]

It looks like my implementation is similar to Martin's. I think that adding features such as scalar product and change basis are for another ticket, but I agree that they would be useful.

[mantepse]

Do you think it would be possible to also support the following?

sage: s = SymmetricFunctions(QQ).s()
sage: X = tensor([s([1]), s([])])
sage: Y = tensor([s([]), s([1])]);
sage: X(s[2])
s[2] # s[]
sage: Y(s[2])
1/2*s[] # s[1, 1] + 1/2*s[] # s[2] - 1/2*s[1, 1] # s[] + 1/2*s[2] # s[]

[zabrocki]

Hi Martin, What is the definition of that notation? I understand what f(expression) means, but I am not sure if I know a meaning of the definition of (f \otimes g)(expression). Do you have a mathematical reference?

This is also not as easily introduced as you suggest since the parent of tensors of symmetric functions is not currently implemented.

[tscrim]

Replying to zabrocki:

This is also not as easily introduced as you suggest since the parent of tensors of symmetric functions is not currently implemented.

Not quite. There is a parent for s # s, but it is the generic CFM tensor product class. However, it would not be difficult to create such a parent (with perhaps a custom element class), and I think it would be straightforward to plug that into the current framework.

---

Some code comments:

This is a little cleaner:

-tHA = TensorProductsCategory.category_of(HopfAlgebrasWithBasis(R))
+tHA = HopfAlgebrasWithBasis(R).TensorProducts()

Why not this:

-            tparents = list(x.parent().__dict__['_sets'])
+            tparents = x.parent()._sets

For better readability (if it goes slightly over the 80 char/line, that's okay, it's worth it IMO):

            return sum(d*prod(sum(raise_c(r)(c)
                                  * tensor([parent(p[r].plethysm(base(la)))
                                            for (base,la) in zip(tparents,trm)])
                                  for (trm,c) in x)
                              for r in mu)
                       for (mu, d) in p(self))

[git]

Branch pushed to git repo; I updated commit sha1. New commits:

​a769527

making code a little cleaner

[mantepse]

In short, I think I should take back my suggestion.

Replying to zabrocki:

What is the definition of that notation?

It appears at the bottom of page 6 of ​https://arxiv.org/abs/math/0307383, Lambda(r) is defined on top of page 5. Just as in Macdonald, the tensor positions correspond to the conjugacy classes of the cyclic group 1, zeta, zeta^2, ...

This is less artificial than it may look, it makes symmetric functions into a plethory, ​https://arxiv.org/abs/math/0407227v1.

On the other hand, it is more specialised than it looks, because it is the special case of the cyclic group of the more general definition on page 9 of ​https://arxiv.org/abs/math/0604126. Again, one needs to identify the conjugacy classes of a finite group with the tensor positions.

[mantepse]

I don't now why, but my version is *much* faster:

sage: X = tensor([p([1]), p([])]); Y = tensor([p([]), p([1])]);
sage: H = sum(h[n] for n in range(7));
sage: timeit("myplethysm(H, X*Y)")
5 loops, best of 3: 270 ms per loop
sage: timeit("H(X*Y)")
5 loops, best of 3: 753 ms per loop
sage: H = sum(h[n] for n in range(8));
sage: timeit("myplethysm(H, X*Y)")
5 loops, best of 3: 508 ms per loop
sage: timeit("H(X*Y)")
5 loops, best of 3: 1.97 s per loop

[git]

Branch pushed to git repo; I updated commit sha1. New commits:

​fd3082d

change order in which change of basis is done

[zabrocki]

Good call. It should compute in the p-basis and then change to its target instead of changing to the target during the computation. The previous version computed target(p_r[expression_1]) \otimes ... \otimes target(p_r[expression_k]) and then took their product. This new version had comparable timings on my computer.

[mantepse]

Many thanks, looks good!

[mantepse]

Dear Travis,

do you have an idea how/where we should provide methods change_basis, restrict_degree, diagonal and scalar?

• change_basis would take a tensor product of symmetric functions and a tuple of as many bases as there are tensor positions. It's somehow like a "diagonally applied plethysm". Maybe we want to write:

  sage: tensor([s,h])(X*Y)
  s[1] # h[1]
  

• for restrict_degree, I'd like to write

  sage: ((X+Y)^2).restrict_degree([1,2])
  p[] # p[1, 1] + 2*p[1] # p[1]
  

• similarly, for diagonal and scalar

[tscrim]

I would just implement a TensorProducts category for the Sym bases with the appropriate methods in the ParentMethods.

[mantepse]

Replying to tscrim:

I would just implement a TensorProducts category for the Sym bases with the appropriate methods in the ParentMethods.

Alas, I have absolutely no clue what I'd have to type into the editor to achieve this :-(

Help appreciated, but I'm afraid I cannot contribute much besides what is in the attached file.

Best wishes,

Martin

[vbraun]

Reviewer name missing

[mantepse]

Oh, I'm very sorry, that was autofill, probably! Thanks for correcting!