Define tensor symmetries in terms of Young tableaux

[Nils Albin Nilsson]

Hello all, 

I am trying to implement some tensors with complicated index symmetries. The tensors  have a minimum of six indices, whose symmetries are defined through a Young tableau. I would like to define this tensor whilst taking into account all symmetries.

I am aware of the YoungProject functionality in xAct, but it does not seem to be what I need. Is there a way to use a YoungTableau in this way, something like this:

defTensor[myTensor[a,b,c,d,e,f], myManifold, myYoungTableau]

Many thanks in advance. 

Albin

[Thomas Bäckdahl]

Hi!

I guess that what you would like to have is a way to tell ToCanonical that your tensor has a Young tableau symmetry and fully take that into account when canonicalizing. So that for instance the first Bianchi identity is automatic.
As far as I know no one has implemented this because it is fairly difficult to do because the symmetry involves several terms. A few of us have been thinking about it a bit, but we have not found any good solution and implementation.

The main things that are implemented are a few functions in xTras.
xTensor can only handle permutation groups as symmetries for the tensors.
You can use TableauSymmetric to extract the symmetry group from your tableau.
For instance

DefTensor[myTensor[a,b,c,d,e,f], myManifold, TableauSymmetric[myYoungTableau]]

To handle the rest of the tableau symmetries you probably have to apply your Young projectors in a fairly manual way.

There is also a new package xBrauer that might be useful when dealing with symmetries of this kind
https://github.com/THelpin/xBrauer_Bundle

If you are willing to work in 1+3 dimensions and use spinors and their irreducible decompositions, this becomes much easier and can be handled with the SymManipulator and SymSpin packages.
I can give you examples if you like.

Regards
Thomas

--
You received this message because you are subscribed to the Google Groups "xAct Tensor Computer Algebra" group.
To unsubscribe from this group and stop receiving emails from it, send an email to xact+uns...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/xact/9a05d007-0ab3-435e-ada4-8215751b1eddn%40googlegroups.com.

[Nils Albin Nilsson]

Hi Thomas, 

thanks for the detailed reply. I used TableauSymmetric for my three simplest tensors and checked the number of independent components. This seems to be enough for a simple Young tableau, but not for the more complicated ones, where symmetries are lost. I think I have to implement the rest with projectors as you suggested, so I have some beginner questions: 

which symmetries are 'caught' by the TableauSymmetric[myTableau], and do you have any advice on how to implement the remaining ones? If this could be handled by xBrauer more easily, I would be happy to try it.

I attached an example notebook. 

Many thanks, 

Albin

[Thomas Bäckdahl]

Hi!

TableauSymmetric[myTableau[[1]]]
gives a strong generating set for the symmetry group. The second part of that is just a list of generators for the symmetry in Cycles notation.
This is the only part of the Tableau symmetry that xTensor can handle at the moment.
These are the mono-term symmetries, i.e. symmetries that takes one term with some index permutation and produces one term with another index permutation.

What remains are the multi-term symmetries. In your case you can describe them by that the tensor should equal the Young projector acting on the tensor.
Hence, the last lines of your code is not counting the number of independent components, but the number of terms in the remaining multi-term symmetries.
What one would like is to have a canonicalizer that can take these 10, 184 or 574 terms and turn them into one term. However, in computer algebra it is always a bad idea to try to find patterns with several terms. What you want is some rule that can take one term and turn it into several terms. If this is done in a clever way one can get cancellations when this is done on several terms.

The simplest case is if you have a two index tensor. Then you can split it into symmetric and antisymmetric parts with
T_{ab}=T_{(ab)}+T_{[ab]}
Now, if you would do that on T_{ba} instead and canonicalize the answer you get
T_{ba}=T_{(ab)}-T_{[ab]}
Hence, T_{(ab)} and T_{[ab]} forms a basis for all index permutations of T_{ab}.

For your problem you would need some generalization of this to arbitrary number of indices and implicit Young symmetrizers instead of T_{(ab)} and T_{[ab]}. You also need to understand how permutations interact with Young symmetrizers and some orthogonality relations between different Young symmetrizers.
Unfortunately, I don't know the algebra well enough to be able to implement this. If indeed it is possible to do it this way.

This problem is really fundamental and one of the main reasons I have almost entirely switched to two-spinor notation instead. With spinors, this decomposition is much simpler and I have already implemented it in SymManipulator and the remaining algebra in the SymSpin package. With spinors you also get trace decompositions for free.

However, I think it would be good to understand this problem and have an implementation in xAct.

I don't know yet what has been implemented in the xBrauer package, but there is a paper describing the algebra here:
https://arxiv.org/abs/2212.14496

Regards
Thomas

To view this discussion on the web visit https://groups.google.com/d/msgid/xact/c7e8dfe0-07f4-409c-8b90-882dd815475cn%40googlegroups.com.

[Obinna Umeh]

Hi Thomas

There is a three-index tensor implementation of what you have just described for a two-index tensor here

https://arxiv.org/abs/gr-qc/9611003

It also made use of Young diagrams for the irreducible decomposition. It is described in pages 6 and 7. 

A generalisation to any index tensor formed from a spatial derivative of any index-1 symmetric tensor is described here: https://arxiv.org/abs/1102.4265

Cheers

Obinna

To view this discussion on the web visit https://groups.google.com/d/msgid/xact/0a403f39-e837-d01d-5fff-6c47dfd89d83%40gmail.com.