All those Platonic polyhedral groups are subgroups of SO(3) which has double cover SU(2). There are connections (see [Con99]) to so called icosians, quaternions, the E8- as well as even the Leech-lattice. Some people call the icosians the group algebra of A(5), and others treat the icosian ring as the 'Z-span of the root system of the non-crystallographic Coxeter group H₄'. The Binary Polyhedral Groups (as well called covering groups) for our three examples are 2.A(4) ≅ SL(2,3) , 2.S(4) and 2.A(5) ≅ SL(2,5) . We speak of a Double Binary Polyhedral Group when reflections are also included. And the universal cover has to do with an embedding into a simply-connected group.

Now (we follow [Gri98]) let K, E, G be some groups, then the following short sequence:

See [Hup67] and [Gor82] a representation group (Darstellungsgruppe) is a group E which is a central extension of G such that the following diagram (Equation 11.4, “Commutative Diagram”) commutes:

A(4) ≅ (Z(2) × Z(2)) : Z(3) and Ê 6 2.A(4) is actually (see [Cip00]) Q : Z(3) ≅ SL(2,3) and the preimage of A(4) in SU(2), so the stuff below becomes a short exact sequence:

The perfect double cover 2.A(5) of A(5) is the icosian group and as well called the Binary Icosahedral group. See Chapter 15, Lattices for more information about the quaternions and icosians.

Now let's see if the Binary Polyhedral Groups are split or not:

gap>G:=AlternatingGroup(5);;
gap>d:=SchurCover(G);;
gap>i:=Image(IsomorphismPermGroup(d),d);;
gap>l:=NormalSubgroups(i);;
gap>GG:=i/l[2];;
gap>IsomorphismGroups(GG, G);
ok
gap>hom:=NaturalHomomorphismByNormalSubgroup(i,l[2]);;
gap>IsomorphismGroups(ImagesSource(hom),G);
ok
gap>FactorGroup(i,l[2]);;
gap>OneCocycles(i,l[2]);
... isSplitExtension := false
gap>sp25:=Sp(IsMatrixGroup,2,5);
SL(2,5)
gap>IsSimple(sp25);
false;
gap>IsSolvable(sp25);
false;
gap>RadicalGroup(sp25);;
gap>u:=SylowSubgroup(sp25,2);; Size(u); 
8
gap>Size(Normalizer(sp25,u));
24
gap>Size(Centralizer(sp25,u));
2

Well, let's for now continue with the cover thing. When we start with the 'vector' group G of the ico_stl_II example:

gap>AbelianInvariantsMultiplier(G);
[ 2, 2 ]
gap>SCG:=SchurCover(G);;
gap>Size(SCG)/Size(G);
4

It seems now there some deeper work is needed what we shouldn't postpone for too long. For a finite group G being polycyclic and solvable are the same. In that case all is feasable of course (doubletetra example, other candidates are rhombic_dode, rubik_cube 2 and 3, costa, dcb_068, oct_stl_II etc.):

gap>Size(G);
648
gap>IsSolvable(G);
true;
gap>gp:=Image(IsomorphismPcGroup(G));;
gap>mats:=List( Pcgs(gp), x -> IdentityMat(1, GF(2)) );;
gap>M:=GModuleByMats(mats, GF(2));;
gap>TwoCohomology(gp,M);;
gap>li:=Extensions(gp, M);;
gap>List(li, ModuleOfExtension);;
gap>cli:=List(li, h -> Intersection(Centre(h), DerivedSubgroup(h)));;
gap>AbelianInvariants(Centre(li[4]));
[ 2 ]
gap>sc:=SchurCover(G);;
gap>iso:=IsomorphismGroups(li[2], sc);
fail
gap>iso:=IsomorphismGroups(li[4], sc);
ok

Alternatively we can use another package:

gap>LoadPackage("polycyclic");;
gap>gpc:=Image(IsomorphismPcpGroup(G));;
gap>mats:=List( Pcgs(gpc), x -> IdentityMat(1, GF(2)) );;
gap>cr:=CRRecordByMats(gpc,mats);;
gap>TwoCohomologyCR(cr);;
gap>ExtensionClassesCR(cr);;

In general unfortunately things aren't that easy :-(. Perhaps (regarding all our graph examples) it's possible to construct Schur covers for all the 'vector' groups or at least (if this is more feasable) directly their character tables (maybe from the tables of the maximally cyclic central extensions or s.th.) for the McKay thing (see the section called “ McKay Correspondence ”)?

Well, the polyhedral groups and their binary counterparts have defining relations (Table 11.3, “Relations of (Binary) Polyhedral Groups”).

To concretize the statements above there is a lot of talking (see [Hsu00]) about central extensions of triangle groups, like

< a,b,c,z with 1=[z,a]=[z,b]=[z,c]
	    and  a^1 = z^p, b^m = z^q, c^n = z^r, abc = z^s >

where z is some torsion generator of course. There is a straight-forward way then to arrive at some Seifert groups and 3-string braid groups B₃ = <p/q, q/m, r/n>, especially <1/3, -1/2, 0>. Well, and then it's time to speak about 'moonshine'.

gap>LoadPackage("cohomolo");;
gap>G:=AlternatingGroup(5));;
gap>chr:=CHR(G,2);;
gap>SetInfoLevel(InfoCohomolo,1);
gap>SchurMultiplier(chr);
#I  Indices in the subgroup chain are: 5 3
...
[ 2 ]
gap>CoveringGroup(chr);;

For now let's take a look (Table 11.4, “Schur multiplier”) at the Schur multipliers for all our graph examples for the 'vector' group (of piece A type), not the rot/flip thing (we write [remedy] in case some helping measures would be needed for further accomplishments).

Let's take a cube with group S(4) and a Chess piece of type A (Example 11.2, “Cube and Schur Cover”).

gap>G := Group(
	(11,10,12,13)(1,7,6,5)(2,16,17,18)(19,9,3,20)(23,8,15,22)(4,24,21,14),
	(1,2,3,4)(7,8,9,10)(19,17,6,21)(5,13,20,22)(23,18,12,24)(11,16,15,14)
);;
gap>SCG := Group(
	(1,7,6,5,25,31,30,29)
	(2,16,17,18,26,40,41,42)(3,20,19,9,27,44,43,33)(4,24,21,14,28,48,45,38)
	(8,15,46,47,32,39,22,23)(10,36,37,35,34,12,13,11),
	(1,2,3,4,25,26,27,28)
	(7,8,33,10,31,32,9,34)(6,45,43,41,30,21,19,17)(5,13,44,22,29,37,20,46)
	(16,15,38,11,40,39,14,35)(18,12,48,23,42,36,24,47)
);;

Decisive is the question if a label (in some atlas net) can be recycled or not. Probably this can be described in the context of maximal edge trees and those known paper model constructions. Remember that we mentioned some full (counter-clockwise) spin when introducing the 'vector' groups and looking at [a,b]³ or (abc)⁴? Actually this same occurs when doing a⁴ or b⁴, and so we double the label set. Only after two full rotations the original situation is reached again. Somehow this means thinking modulo 2, and a full clockwise rotation (consisting of poly-many atomic rots) gives the same as a full counter-clockwise rotation. This is not ad hoc, because depending on if you shrink to the left or the right you get rot⁴ or rot^-4, what must be in fact equal (it simple shouldn't matter which direction we preferred). It seems this is because it's not possible to store more information (than these two states) in such a short cycle (compare the section called “Morphing Group” where we speak about the finiteness of the morphing groups). Actually for bigger graphs we cannot simply only double the label set, instead we will later on use for example GF(8) for a Binary double-tetra cover, but forget about this for now.

The next easy example is the tetrahedron, you will manage for yourself. We will give you some hints: you will have to insert 'on the line', that is aaa=(bb^-1)aaa=b(aa^-1)b^-1aaa=rot^-1a^-1b^-1aaa = … etc., and it's a good idea to move negative powers of rot to one side (left) and positive powers to the other (right). Besides you will make use of dual_rot local_dual_valence = -1 = rot poly finally. Come on, just try and feel the spirit.

Interesting to visualize how such a loop gets moved on the graph while collecting information about the torsion thereby …

By the way, such things like [rot, flip]=? and rota=brot belong to the field of vector analysis or exterior Grassmann algebra perhaps? Well, the latter equation can be equivalently formulated as: the two automorphisms "a" and "b" (of some algebra) are similar, there exists an intertwining automorphism called "rot". Actually all stuff gets involved in our project, yeah.

gap>sc:=SchurCover(PGL(2,3));;
gap>IsomorphismGroups(sc, GL(2,3));
ok
gap>IsomorphismGroups(sc, SCG);
fail
gap>IsPerfect(G);
false

As we know the desired group is not uniquely determined, so no problem with that output above either.

Let's take a look at the following lovely little script (see the GAP™ source code in the file lib/schur.gi) for computing a finite presentation of a representation group (Darstellungsgruppe) of a finitely presented group, using the Hopf formula. Simply take a finite presentation F/R for a group G and compute a presentation of one of G's representation groups (Darstellungsgruppen, Schur covers). This is done by assembling a presentation for F/[R,F] and then finding a generating set for a complement C/[R,F] for the intersection of R and [F,F] in R/[R,F] (all possible covers would be achieved by computing all complements).

  1 gap>DarstellungsgruppeFP := function( G )
    	local g, i, m, n, r, D, I, M, M2, fgens, rels, gens, Drels;
    
    	fgens:=FreeGeneratorsOfFpGroup(G);
  5 	rels:=RelatorsOfFpGroup(G);
    	n := Length( fgens );
    	m := Length( rels );
    	    
    	D := FreeGroup( n+m );
 10 	gens:=GeneratorsOfGroup(D);
    	Drels := [];
    	for i in [1..m] do
    	   r := rels[i];
    	   Add(Drels, MappedWord( r, fgens, gens{[1..n]} ) / gens[n+i] );   
 15 	od;
    	for g in gens{[1..n]} do
    	   for r in gens{[n+1..n+m]} do
    	      Add( Drels, Comm( r, g ) );
    	   od;
 20 	od;
    	    
    	M := [];
    	for r in rels do
    	   Add( M, List( fgens, g->ExponentSumWord( r, g ) ) );
 25 	od;
    	    
    	M{[1..m]}{[n+1..n+m]} := IdentityMat(m);
    	M := HermiteNormalFormIntegerMat( M );          
    	M:=Filtered(M,i->not IsZero(i));
 30 	    
    	r := 1; i := 1;
    	while r <= m and i <= n do
    	   while i <= n and M[r][i] = 0 do
    	      i := i+1;
 35 	   od;
    	   if i <= n then  r := r+1; fi;
    	od;
    	r := r-1;
    	    
 40 	if r > 0 then
    	   M2 := M{[1..r]}{[n+1..n+m]};
    	   M2 := HermiteNormalFormIntegerMat( M2 );     
    	   M2:=Filtered(M2,i->not IsZero(i));
    	   for i in [1..Length(M2)] do
 45 	      Add(Drels,LinearCombinationPcgs(gens{[n+1..n+m]},M2[i]));
    	   od;
    	fi;
    	    
    	D:=D/Drels;
 50 	return D;
       end;

here HermiteNormalFormIntegerMat is used

Let G denote our holonomy group and GSC our cover, as shown below using the double-tetrahedron example:

gap>gens:=GeneratorsOfGroup(G);;
gap>iso:=IsomorphismFpGroupByGenerators(G, gens);;
gap>G_fp:=Image(iso);;
gap>dar:=DarstellungsgruppeFP(G_fp);
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8 ]>
gap># (now K:=SimplifiedFpGroup(dar);; would be an option)
gap>P:=PresentationFpGroup(dar);;
gap>TzOptions(P).protected:=2;;
gap>TzOptions(P).printLevel:=2;;
gap>TzOptions(P).loopLimit:=10;;
gap>v:=GeneratorsOfPresentation(P);;
gap>TzEliminate(P,v[3]);;
gap>SimplifyPresentation(P);;
gap>K:=FpGroupPresentation(P);
<fp group on the generators [ f1, f2 ]>
gap>is:=IsomorphismPermGroup(K);;
gap>K_p:=Image(is);;
gap>SmallerDegreePermutationRepresentation(K_p);;
IdentityMapping( <permutation group of size 1296 with 2 generators> )
gap>NrMovedPoints(K_p);
 432

That's too much, and for bigger graphs the isomorphism to a permutation group is anyway not feasable anymore. Can we find a better solution?

gap>tom:=TableOfMarks(K_p);;
gap>ctl:=CharacterTable(K_p);;
gap>trueperms:=PermCharsTom(ctl,tom);;

There are for example some of degree 36, but how to go from such a character to the corresponding representation? And while they are not just possible candidates for characters, still that's only a necessary (and not sufficient) condition for s.th. faithful. Actually the kernel of a character are all group elements where the character has got the same value as for the identity element, and the corresponding representation is faithful if and only if the kernel is trivial (so in the example above 48 could be the minimal degree).

By the way, here you get s.th. isomorph to G on just 9 points (but somehow we still prefer the 18 points, probably because then we need only two generators):

gap>blocks:=Blocks(G, MovedPoints(G));
[ [ 1, 3 ], [ 2, 4 ], [ 5, 10 ], [ 6, 11 ], [ 7, 12 ], [ 8, 13 ], [ 9, 14 ], 
  [ 15, 16 ], [ 17, 18 ] ]
gap>blockhom:=ActionHomomorphism(G,blocks,OnSets);;
gap>Gb:=Image(blockhom);;
gap>IsomorphismGroups(G,Gb);;
gap>Length(GeneratorsOfGroup(Gb));
 7

Actually the question arises what is the minimal degree of a faithful permutation representation for our cover. It is the index of the largest core-free subgroup. Well, core-free is definitely not a synonym for Abelian. Let us mention that a permutation representation of degree n is actually a homomorphism into S(n) and leave this minimality problem for the moment.

For bigger examples the approach above is not feasable, and we don't like the big degree 432 anyway. We will now very closely follow [Hul01a] (more often than not by copy/paste whole passages, but we must be explicit in our construction for a wide, unexperienced audience) and lift our permutation representation for G of degree 18 to a cover (on 144 labels). Perhaps (see the mentioned paper for the actual state of the art) it is not completely sophisticated to work with some arbitrary Darstellungsgruppe, but for the moment this will just suffice:

gap>h:=GroupHomomorphismByImages(K,G,GeneratorsOfGroup(K),GeneratorsOfGroup(G));
[ f1, f2 ] -> [ (1,2,3,4)(5,15,11,8)(6,13,10,16)(7,17,14)(9,12,18), 
  (1,5,6)(2,7,8,9)(3,10,11)(4,12,13,14)(15,17,16,18) ]
gap>Size(Image(MaximalAbelianQuotient(K)));
2
gap>DerivedSubgroup(K);
Group([  f1^-2, f2*f1^-1  ])
gap>Size(last)
648
gap>Size(Kernel(h));
2

The kernel(h) must be ≤ K', that means the largest Abelian quotient of the cover K ≅ that of G . Now let s be the subgroup which is the preimage of a point stabilizer:

gap>s:=PreImage(h,Stabilizer(G,1));; Index(K,s);
18
gap>h2:=IsomorphismFpGroup(s);;
gap>q:=Range(h2);;

Next, we compute the permutation images of the (new) generator preimages under the epimorphism onto G and construct the corresponding epimorphism from the new fp group onto the point stabilizer in G.

gap>gens:=List(GeneratorsOfGroup(q),i->Image(h,PreImagesRepresentative(h2,i)));
[ (7,14,17)(9,18,12), (2,9,8,7)(4,14,13,12)(15,18,16,17) ]
gap>h3:=GroupHomomorphismByImages(q,Subgroup(G,gens),GeneratorsOfGroup(q),gens);
#I  CosetTableFromGensAndRels called:
#I  	2	1	1	2
#I  CosetTableFromGensAndRels called:
#I  	2	1	1	2
[ F1, F2 ] -> [ (7,14,17)(9,18,12), (2,9,8,7)(4,14,13,12)(15,18,16,17) ]
gap>o:=Orbits(Range(h3),[1..18]);
[ [ 1 ], [ 2, 9, 8, 13, 7, 18, 16, 12, 4, 15, 14, 17 ], [ 3 ], 
 [ 5 ], [ 6 ], [ 10 ], [ 11 ] ]

Taking the orbit of length 12 now would give the inferior result on 432 points from above.

gap>t:=Stabilizer(Image(h3),o[1][1]);
Group([ (7,14,17)(9,18,12), (2,9,8,7)(4,14,13,12)(15,18,16,17) ])
gap>DisplayCompositionSeries(t);;
gap>tp:=PreImage(h3,t);; Index(q,tp);
1

We now compute the epimorphism from tp onto its commutator factor group (by first rewriting the presentation to one of tp and then Abelianizing the presentation, the resulting Abelian quotient of size 8 is represented as a pc group).

gap>maxab:=MaximalAbelianQuotient(tp);; Size(Image(maxab));
8

Let's pull this quotient back to a subgroup of the finitely presented group K (of index 18). For this we need a generating set for this subgroup (which is obtained by taking the primary generators of an augmented coset table).

gap>U:=PreImage(h2,tp);; Index(K,U);
18
gap>Ugens:=GeneratorsOfGroup(U);; Length(Ugens);
4
gap>Umax:=RestrictedMapping(h2,U)*maxab;;

We want to induce this representation to K. Now first of all the ugly way, involving the computation of a stabilizer chain for the permutation image, this won't be ok for bigger groups. The representation below on the cosets is faithful if and only if the core of ke in K (that is the intersection of all K-conjugates of ke) is trivial.

gap>ke:=Kernel(Umax);; Index(K,ke);
144
gap>Core(K,ke);
Group(())
gap>tab:=CosetTable(K,ke);;
gap>tab:=List(tab{[1,3..Length(tab)-1]},PermList);;
gap>kk:=Group(tab);; Size(kk); Size(G);
1296
648

And now instead here comes the better way how to do it. By the Krasner-Kaloujnine embedding theorem, the induced permutation representation goes in a wreath product of the images of the original representation with the permutation representation on the cosets. DefiningQuotientHomomorphism of a subgroup is not necessarily the action on the cosets, but only some homomorphism whose kernel is contained in the subgroup. In this particular case it is this particular homomorphism.

gap>Ucosrep:=DefiningQuotientHomomorphism(U);;
gap>perms:=KuKGenerators(K,Ucosrep,Umax);;
gap>NrMovedPoints(perms);
144

Now we could first of all use IsomorphismSimplifiedFpGroup(K); to find redundant generators within the perms, but for the moment we just take them all. The use of straight line program elements might be overkill in the concrete example but will be appropriate in bigger cases.

gap>p3:=StraightLineProgGens(perms);;
gap>P:=Group(p3);;
gap>StabChainOptions(P).random:=1;; Size(P);
1296
gap>bas:=BaseStabChain(StabChainMutable(P));;
gap>Length(bas);
3

The computed stabilizer chain provides us with a base for the group. Knowledge of this base will speed up comparisons of straight line program elements enormously (we only have to test equality on the 3 points of the base instead of the 144 points of the domain). For the further calculations we therefore create the straight line program generators anew, this time with a base. We also create the permutation group P anew and store its size.

gap>p3:=StraightLineProgGens(perms,bas);; P:=Group(p3);
gap>SetSize(P,Size(G)*2);;

So finally we have the result for our double-tetrahedron example (Example 11.3, “DoubleTetrahedron and Schur Cover”).

gap>GeneratorsOfGroup(G);
[ (1,2,3,4)(5,15,11,8)(6,13,10,16)(7,17,14)(9,12,18), 
  (1,5,6)(2,7,8,9)(3,10,11)(4,12,13,14)(15,17,16,18) 
]
gap>GeneratorsOfGroup(P);
[ (1,9,41,17,2,10,42,18)(3,11,43,19,4,12,44,20)(5,13,45,21,6,14,46,22) ...
, 
  (1,25,33,5,29,37,3,27,35,7,31,39,2,26,34,6,30,38,4,28,36,8,32,40) ...
]

gap>RelatorsOfFpGroup(dar)[1];
 f1^-2*f2^-1*f1^-2*f2^-1*f3^-1
gap>elm:=(P.1^-2*P.2^-1*P.1^-2*P.2^-1) ; Order(elm);
2
gap>S:=SubgroupNC(P,[elm]);;
gap>N:=SolvableNormalClosurePermGroup(P,S);;

gap>IsElementaryAbelian(N);
true
gap>pcgs:=Pcgs(N);;
gap>mats:=LinearActionLayer(P,pcgs);
gap>module:=GModuleByMats(mats,GF(2));
rec( field := GF(2), isMTXModule := true, dimension := 1, 
  generators := [ <an immutable 1x1 matrix over GF2>, 
	          <an immutable 1x1 matrix over GF2> ] )
gap>MTX.IsIrreducible(module);
true

Let's investigate the results for oct_stl_I (small tetrahedron reticulated) type A holonomy group (Example 11.4, “Tetrahedron Reticulated and Schur Cover”).

gap>GeneratorsOfGroup(G);
[ (1,2,3)(4,19,13,20,21,22)(5,17,23,24,25,26)(6,27,28) ...
, 
  (1,4,5,6,7,8)(2,9,10,11,12,13)(3,14,15,16,17,18)(19,37,36) ...
]
gap>GeneratorsOfGroup(P);
[ (1,9,17,8,16,24,2,10,18,7,15,23)(3,11,19,5,13,21,4,12,20,6,14,22) ...
, 
  (1,25,89,217,116,35)(2,26,90,218,115,36)(3,27,91,219,113,34) ...
]

gap>G;
Group([ (1,2,3,4)(5,6,7,8), (1,5)(2,6)(3,7)(4,8) ])
gap>P;
Group([ (1,2,6,3)(4,8,12,10)(5,7,13,9)(11,14,16,15), 
        (1,4,11,5)(2,7,14,8)(3,9,15,10)(6,12,16,13) ])

Finally we present the result for the deltoid (stellated tetrahedron) (see Example 11.6, “Tetrahedron Stellated and Schur Cover”).

gap>G;
Group([ (1,2,3,4,5,6)(7,28,25)(8,26,29,20,17,30)(9,23,16) ...
, 
        (1,7,8,9,10,11)(2,12,13)(3,14,15,16,17,18)(4,19,20) ...
])
gap>P;
Group([ (1,2,6,18,9,3)(4,12,35,79,37,13)(5,15,43,67,46,16) ...
, 
        (1,4,14,42,17,5)(2,7,23,65,26,8)(3,10,31,82,34,11) ...
]);

Let's assume that now we know how to construct the cover for ourselves. This might turn out to be beneficial as soon as parts of the construction above become too complicated for really big graphs.

We embed our holonomy groups into s.th. else. The character tables apparently tell us if the covers have a faithful two-dimensional representation. Running through some class representative and so on will perhaps be a next step. Our final aim then are generic character tables for all our graphs!

How is the cover of the holonomy group (of piece type A) in relation to those for the other piece types?

At the moment we restricted ourselves to genus 0 graphs because there is only the 'shrinking to a point', on other graphs we have additional entities (the good old torus knots and so on) against which to check if we have a rotation or not. But there is no principal problem anymore to come. Btw. we could moreover add some rotation (and perhaps even some 'boost' thing) generator as well in cases where it would make a difference.

gap>ctl:=CharacterTable(P);
gap>Length(Irr(ctl));
gap>CharacterDegrees(ctl);

Here (Table 11.5, “Holonomy Group Schur Covers”) are some results for various graphs (multiplier, sheets, number of conjugacy classes of a Schur cover (what is the same as the number of Irrs), and the lists of degrees of the absolutely irreducible complex characters). Remember that for example in case of M(24) we have a boundary and reflection, the two-sheeted covering arising because of this has already been incorporated into our holonomy groups, and here only the number of sheets caused by the additional embedding into GL is taken into account.

We might speculate that things like invariant metric or bilinear forms in general can now be retrieved as module isomorphisms from some module M over GF(q) defined by G to its dual module (see [Hol05]).

Finally anyway it's all about a representation involving some field or ring. And every matrix group is a Lie group, so we are safe to say that our embedding and their projections (the holonomy groups) have to do with Lie algebras, yep.

Last but not least (see [Gri99]) one can think about embedding into (instead of GL only) linear algebraic groups in general. Perhaps the icosahedron's morphing group from below needs some twistors to become E8?!