friedrichrober / wpe Goto Github PK

When I began to implement the package I used the GAP lib internal WreathProductElement for everything and implemented methods for this representation. Then I transitioned from WreathProductElement to a List representation as provided by the now available interface in GAP lib, namely via the methods WreathProductElementList and ListWreathProductElement. In this process I simply added these methods for List, which is not the best way to do it, but it was convenient for transitioning, since I was able to work on parts of the code rather than having to rewrite everything before being able to test the code.

Now the question is how to proceed from here? Remove all methods for WreathProductElement and hide them internally. Or should these methods be somehow available to the User?

All this code is in the file WreathProductElements.gi and WreathProductElements.gd.

Maybe we should have actions for the generic wreath products. For example this is the product action:

OnTuplesGenericWreathProductProductAction := function( pnt, element)
    local sigma;
    sigma := Top(element)^-1;
    return List( [1 .. Size(pnt)], i-> pnt[i^sigma]^Base(element, i^sigma));
end; 

And similarly the imprimitive action.

It would be nice to have functions BaseGroupGenericWreathProduct(G) and TopGroupGenericWreathProduct(G) returning the Base- and Topgroup of generic wreath products G.

I use some information from WreathProductInfo for this package. Unfortunately this method is currently undocumented in GAP. I suggest to add a documentation for some entries in this record.

• groups : the groups used to construct the WreathProduct
• I : the actual permutation representation for the top component group
• degI : degree of I
• alpha : homomorphism from groups[2] to I, used for translation.

Example, using hom to embed top group into larger group:

gap> K := SymmetricGroup(4);;
gap> H := SymmetricGroup(5);;
gap> hom := GroupHomomorphismByImages(H, SymmetricGroup(7), [(1,2),(1,2,3,4,5)], [(2,3),(2,3,4,5,6)]);
[ (1,2), (1,2,3,4,5) ] -> [ (2,3), (2,3,4,5,6) ]
gap> G := WreathProduct(K, H, hom);
<permutation group of size 550376570880 with 16 generators>
gap> info := WreathProductInfo(G);;
gap> Display(info);
rec(
  I := Group( [ (2,3), (2,3,4,5,6) ] ),
  alpha := GroupHomomorphismByImages( SymmetricGroup( [ 1 .. 5 ] ), SymmetricGroup( [ 1 .. 7 ] ), 
    [ (1,2), (1,2,3,4,5) ], [ (2,3), (2,3,4,5,6) ] ),
  base := Group( [ (1,2,3,4), (1,2), (5,6,7,8), (5,6), ( 9,10,11,12), ( 9,10), (13,14,15,16), (13,14), 
      (17,18,19,20), (17,18), (21,22,23,24), (21,22), (25,26,27,28), (25,26) ] ),
  basegens := [ (1,2,3,4), (1,2), (5,6,7,8), (5,6), ( 9,10,11,12), ( 9,10), (13,14,15,16), (13,14), (17,18,19,20), 
      (17,18), (21,22,23,24), (21,22), (25,26,27,28), (25,26) ],
  components := [ [ 1 .. 4 ], [ 5 .. 8 ], [ 9 .. 12 ], [ 13 .. 16 ], [ 17 .. 20 ], [ 21 .. 24 ], [ 25 .. 28 ] ],
  degI := 7,
  domI := [ 1 .. 7 ],
  embeddingType := NewType( NewFamily( "GeneralMappingsFamily", [ 419 ], [ 82, 83, 117, 120, 123, 127, 133, 152, 419 
     ] ), [ 36, 41, 82, 83, 117, 120, 123, 127, 133, 152, 419, 420, 431, 432, 433, 434, 435, 436, 451, 452, 453, 
      454, 455, 456, 2092, 2093 ], fail ),
  embeddings := [  ],
  groups := [ SymmetricGroup( [ 1 .. 4 ] ), SymmetricGroup( [ 1 .. 5 ] ) ],
  hgens := [ ( 5, 9,13,17,21)( 6,10,14,18,22)( 7,11,15,19,23)( 8,12,16,20,24), ( 5, 9)( 6,10)( 7,11)( 8,12) ],
  permimpr := false,
  perms := [ (), (1,5)(2,6)(3,7)(4,8), ( 1, 9)( 2,10)( 3,11)( 4,12), ( 1,13)( 2,14)( 3,15)( 4,16), 
      ( 1,17)( 2,18)( 3,19)( 4,20), ( 1,21)( 2,22)( 3,23)( 4,24), ( 1,25)( 2,26)( 3,27)( 4,28) ] )

In standard GAP those elements are printed like this :

(We suppose we continue the session from the Introduction)

gap> L := [ (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), () ];;
gap> pi := (1,3)(2,7,5);;
gap> WreathProductElementList(W, Concatenation(L, [pi]));
WreathProductElement((1,3,4,2,5),(2,5)(3,4),(),(3,4,5),(1,2)(4,5),(),(),(1,3)(2,7,5))

Currently I overwrite the Printing, since IMO this looks messy and is hard to read, (Note the semicolon):

gap> WreathProductElementList(W, Concatenation(L, [pi]));
( (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), (); (1,3)(2,7,5) )

I did not want to use [ … ], so that it is not confused with a list.
I am open to suggestions for Printing, for example maybe something like this would look better

gap> WreathProductElementList(W, Concatenation(L, [pi]));
WPE( (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), (); (1,3)(2,7,5) )

Implement a function that checks if a given permutation group that is a subgroup of the base group is a subdirect subgroup of the base group of a generic wreath product. This could be done with 2 versions: A no-check function and a function that checks the input. This could be a first draft:

__IsSubdirectSubgroupOnGivenSetGenericWrNC := function( sizeComponentG, H,ell )
    local componentsH;
    componentsH := List([1 .. ell], i-> Group(List(GeneratorsOfGroup(H), gen -> Base(gen,i))));
    if ForAll( [1..ell], i-> sizeComponentG=Size(componentsH[i])) then 
        return true;
    else 
        return false;
    fi;
end;

Please note that this function only works if the base group is G^ell, where |G|=sizeComponentG but it can be adjusted easily.

Currently we use a WreathProductDecomposition in our internal methods, which blows up the storage space of a wreath product element w with m component to O(m^2) many base components. It would be much more convenient to use a TerritoryDecompositionByWreathCycle, which adds a storage of O(m) many integers (as permutations or singeltons) and access the components of the element directly via this decomposition. A Wreath Cycle is then uniquely identified by the element w and the top cycle permutation or singleton from the TerritoryDecompositionByWreathCycle.

It would be great if this package was submitted for inclusion within the GAP package distribution.

Are there any blockers for this from your point of view?

I think that knowing the territory decomposition for conjugacy classes of wreath products with a symmetric top group maybe could be useful for doing representation theory with such groups.

Say G = K wr H where H is a symmetric group of degree m and K has r conjugacy classes with representatives k_1, ..., k_r. Then we would store for each conjugacy class a matrix P of size r x m where the entry P_{i,j} encodes the number of wreath cycles with load (k_i, j).

This method has been used at the beginning to translate from Wreath Product Representations as Perm or Matrix Groups to Generic Representations that use WreathProductElement. I know that this method is already used by @DominikBernhardt for his PhD project, so this method has to stay.

After discussions with Alexander Hulpke and Max Horn, I dismissed using this isomorphism internally, since we did not want to bother with creating a generic wreath product all the time and use WreathProductElementList and ListWreathProductElement directly.

My question is how to properly document this method now, as this method is simply there for convenience for the User rather than for the internal code.

The functions Base and Top should be renamed to BaseComponentOfGenericWreathElement and TopComponentOfGenericWreathElement to avoid confusion with other concepts, e.g. of bases of permutation groups.

Add an example session and explain how to construct wreath product elements.
There exist two ways how to construct such elements, and they are part of GAP lib now.

First way using the Low-Level function ListWreathProductElement and WreathProductElementList (code that moved from package to GAP lib).
These are used in the background for the Isomorphism.

(We suppose here that we continue the example session from the Introduction)

gap> L := [ (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), () ];;
gap> pi := (1,3)(2,7,5);;
gap> WreathProductElementList(G, Concatenation(L, [pi]));
(1,13,3,14,4,12,2,15,5,11)(6,31,21,7,35,25,9,33,23,8,34,24,10,32,22)(18,19,20)
gap> WreathProductElementList(W, Concatenation(L, [pi]));
( (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), (); (1,3)(2,7,5) )

Second way, using Embedding, which is a bit cumbersome for such dense elements, but is nice for sparse elements

gap> (1,3,4,2,5) ^ Embedding(G, 2) * pi ^ Embedding(G, 8);
(1,11)(2,12)(3,13)(4,14)(5,15)(6,33,23,8,34,24,9,32,22,7,35,25,10,31,21)
gap> (1,3,4,2,5) ^ Embedding(W, 2) * pi ^ Embedding(W, 8);
( (), (1,3,4,2,5), (), (), (), (), (); (1,3)(2,7,5) ) 

For people completely new to the package, it is confusing that g_i is called the "i-th base component" while f is called the "base component", instead of "base component map" or "base component list" or similar

We should improve the text leading to the definition, in order to explain why these names are intutive ways to describe these concepts.

Some of the provided functions are based on new concepts from the paper. We should include references to the definitions in the paper for such cases, for example Yade

Having duplicate code in WPE_GenericWreathProduct from the GAP lib is not a good idea. This was a workaround for the time being, which should be somehow addressed for the release.

wr := WreathProduct( SymmetricGroup(2), SymmetricGroup(2));
iso := IsomorphismToGenericWreathProduct( wr );
GeneratorsOfGroup(Image(iso, TrivialSubgroup(wr)));

gives an empty list and not the list containing the trivial wreath product element. This is a problem for algorithms that want to access the generators of a group.
This is somewhat urgent and should be fixed.