Partial convert(Array, TensorMap)

[Gertian]

Hi,

First I should mention that this isn't really an issue but rather a feature request. I'll first explain the feature that I think would be useful to implement and then explain the context in which I need this.

Requested feature
Given T::TensorMap with legs that charged under some group G that has a subgroup g, it would be nice to have a convert method (similar to the current Convert(Array, TensorMap) ) that outputs a new tensor t::TensorMapwhose legs are now only charged under g_1.

In particular I'd be interested in the case where g_1 is the FermionParity group.

(I hope this makes sense, if not I suspect the context will make it more clear)

Context
Often in MPSKit we will implement the Hamiltonian with as many symmetries as possible. This makes it easy to implement the Hamiltonian efficiently (since few elements are to be tweaked manually) and speeds up the code later down the line when we exploit symmetric MPS.

However, sometimes the charge density of the GS is unknown so before running the actual symmetric code we might want to perform some MPS sweeps without symmetries. Usually I do this by re-using my symmetric Hamiltonian using the existing Convert(Array, TensorMap). However, when the Hamiltonian has FermionParity it is desirable to keep this so that one does not have to go back in and manually perform Jordan Wigner...

Hence, it would be very nice to have a convert(subgroup, TensorMap) method to deal with this.

Further request
If this is implemented it should be backported to version of TensorKit that is being used by MPSKit. Otherwise my usecase remains unsolved...

[lkdvos]

I fully agree that this would be useful, and this is something that has been discussed quite a few times actually, the main problem here is how to specify what you really want to achieve.

Basically, the outcome is not uniquely specified by simply defining a group and a subgroup. For example, you might say that it is reasonable to break SU(2) to U(1) along the z-axis, but that is of course simply a convention, and any axis might be chosen. The problem kind of shows up when you would want to do something like add a particular magnetic field, which would have to be diagonal in the chosen subgroup for that to work.

A secondary problem is that we are not actually required to choose the same basis in the different symmetric implementations. One example here is that converting a U1 symmetric tensor to an array, the basis would be ordered U1(0), U1(1), U1(-1), U1(2), U1(-2)..., which is not how you would typically write out the basis vectors for a spinsystem. Similarly, a SU2 tensor would first group by total spin, which again gives a different basis from the U1 convention.
As a result, you would have to be very careful when working with these kinds of conversions, because you are then responsible as a user to make sure that you are not mixing tensors that are in different bases. Additionally, depending on the use case, you might want to have a different convention enforced.

In the case of fully breaking a product symmetry, I think everything could be well-defined, so your particular case might work, but again you have to be quite careful with the choice of basis, as simulations obtained from the one symmetry wouldn't necessarily care over to the converted simulations of the other.

Finally, I'm not sure if we have all the data for doing what you want in a general case: we would need to know how the irreps of the subgroup fit in the larger group, and this is currently not part of our interface. I think the relevant terms here are "subduction tables" and "subduction coefficients", but honestly this is not something I know a lot about.

Long story short:

• there are some issues with designing an interface, because somehow the user needs to tell us what basis they want
• there are some easy pitfalls that would give wrong results with not so easy to track down bugs
• there is missing group data to implement this in a general case
• it is probably easier to implement this for specific cases instead, so if you are stuck with a specific case where you know the groups involved and the bases chosen, I can definitely try and help out

[Jutho]

I agree that we are aware that this is useful, but the main reason stopping is so is an incomplete understanding of what is the necessary data, and resulting from that, how to come up with an interface for that.

I would definitely not put this under convert, as it will indeed not be true that convert(Array, tensor_with_full_symmetry) == convert(Array, tensor_with_subgroup_symmetry).

Maybe subduce is a nice word, e.g.

subduce(fullgroup_irrep, ...) = ? # list of irreps and multiplicities for subgroup
subduce(fullgroup_representationspace, ...) = subgroup_representationspace
subduce(fullgroup_tensormap, ...) = subgroup_tensormap

where ... is the Irrep(subgroup) and possibly other data that is needed.

However, this is also related to module categories if I understood correctly, and I think people like @lalooten could instruct us on how to set this up in a categorical way that would fit nicely within the TensorKit structure.

[Gertian]

Thanks for the in depth response, I didn't anticipate that this would be such a subtle topic.
Already these replies learnt me something about group theory 👍

Since my usecase arises in a project with @lalooten he might be tempted to help out with the catogory stuff.
I'm not sure if he ever checks git but I'll tell him to check this out. On the other hand, I think the general method is heavily overkill for what I want to achieve.

More specifically, my particular usecase is sym = (U1Irrep ⊠ U1Irrep ⊠ FermionParity) and like I said, I'd like to subduce so that only the fermionic Z2 remains.

In fact, in general I think that G*FZ2 would be the class of symmetries where such a method is most desirable (as far as I known FZ2 is the only symmetry that encodes some non on-site effect that cannot be ignored by converting to a plain Array). If this is simpler and well defined I'd suggest adding a method that strips all symmetries except fermionic Z2 from some tensor.

Off course I'd be happy to help out with things that do not require deep knowledge of the Tensorkit code.

[Jutho]

It does seem like 'restriction' is the more general term in the math literature. There are "restricted representations", there is a restriction functor in category theory.

This page also has quite a lot of info: https://en.wikipedia.org/wiki/Restricted_representation

Here they talk about branching rules. Not sure if that is the same as the aforementioned subduction coeffs, maybe its math versus physics slang.

So, not that I have anything new to report, other than that maybe restrict is a more descriptive term than subduce.

[lkdvos]

@Gertian , for the case you have in mind, I think you could just convert into an array and then convert into a tensormap, as long as the fermionic symmetry is the first (or last, I might be mistaking) entry in the product sectors. This is a slight hack that makes use of the specific order of the data, but as long as you don't care about the final basis, or you are okay with manually rotating to your basis of choice, this should work. (Check this first though, I am not 100% certain what I'm saying is correct, and it's definitely not robust, in the sense that it makes use of internals)

[Gertian]

This seems to work nicely thanks.
Feel free to close this issue, or keep it open as a reminder :)