We need to construct quantum symmetrizers. First, we define the braiding $c_i$ as an endomorphism of $V^{\otimes n}$. For this purpose, we simply compute $c_i=\operatorname{id}^{\otimes (i-1)}\otimes c\otimes\operatorname{id}^{\otimes(n-i-1)}$.

> Braiding := function(c, i, n)
function> d := Isqrt(Nrows(c));
function> R := BaseRing(c);
function> return TensorProduct(TensorProduct(IdentityMatrix(R, d^(i-1)), c),\
 IdentityMatrix(R, d^(n-i-1)));
function> end function;

We also need the shuffle map, namely $\operatorname{id}+c_1+c_1c_2+\cdots+c_1c_2\cdots c_{n-1}$.

> ProductOfBraidings := function(c, i, n)
function> m := Braiding(c, 1, n);
function> for k in [2..i] do
function|for> m := m*Braiding(c, k, n);
function|for> end for;
function> return m;
function> end function;

Now, to compute the quantum symmetrizer, we use the recursive formula $S_{n+1}=(S_n\otimes\operatorname{id})( \operatorname{id}+c_1+c_1c_2+\cdots+c_1c_2\cdots c_n)$.

> Symmetrizer := function(c, n)
function> d := Isqrt(Nrows(c));
function> R := BaseRing(c);
function> if n eq 1 then
function|if> return IdentityMatrix(R, d);
function|if> end if;
function> m := IdentityMatrix(R, d^n);
function> for i in [1..n-1] do
function|for> m := m + ProductOfBraidings(c, i, n);
function|for> end for;
function> return TensorProduct(IdentityMatrix(R, d), $$(c, n-1))*m;
function> end function;

The following function computes the dimensions of homogeneous components of a Nichols algebra:

> ComputeDimension := function(c, n)
function> if n eq 0 then
function|if> return 1;
function|if> else
function|if> return Rank(Symmetrizer(c, n));
function|if> end if;
function> end function;

Heckenberger’s exercises are the following. Let $V$ be a complex vector space with basis $x_1,x_2$. The braidings are of the form $c(x_i\otimes x_j)=q_{ij} x_j\otimes x_i$ for $i,j\in{1,2}$. There are three braidings to consider:

1. $q_{11}=q_{22}=-1$ and $q_{12}q_{21}=1$.
2. $q_{11}=q_{22}=-1$ and $q_{12}q_{21}=-1$.
3. $q_{11}=q_{22}=-1$ and $q_{12}q_{21}=\omega$, where $\omega^2+\omega+1=0$.

So we create a braiding for each $2\times 2$ matrix $q$.

> DimensionTwoDiagonalBraiding := function(q)
function> local R;
function> R := BaseRing(q);
function> return Matrix(R, [
function|return> [q[1,1], 0, 0, 0],
function|return> [0, 0, q[1,2], 0],
function|return> [0, q[2,1], 0, 0],
function|return> [0, 0, 0, q[2,2]]
function|return> ]);
function> end function;

Let us solve the exercise for the first braiding, namely

> c := DimensionTwoDiagonalBraiding(Matrix(Rationals(), [[-1,-1],[-1,-1]]));
> c;
[-1  0  0  0]
[ 0  0 -1  0]
[ 0 -1  0  0]
[ 0  0  0 -1]

Now use the following code to get some dimensions of homogeneous components:

> c := DimensionTwoDiagonalBraiding(Matrix(Rationals(), [[-1,-1],[-1,-1]]));
> k := 0;
> dim := 0;
> repeat
repeat> d := ComputeDimension(c, k);
repeat> if not d eq 0 then
repeat|if> print d;
repeat|if> end if;
repeat> dim := dim+d;
repeat> k := k+1;
repeat> until d eq 0;
1
2
1
> dim 
4

For the second item, we need to consider the following braiding:

> c := DimensionTwoDiagonalBraiding(Matrix(Rationals(), [[-1,1],[-1,-1]]));
> c;
[-1  0  0  0]
[ 0  0  1  0]
[ 0 -1  0  0]
[ 0  0  0 -1]

The same code, applied to this braiding, produces the sequence of dimensions 1, 2, 2, 2, 1 and hence an algebra of dimension 8. For the third exercise, the braiding is the following:

> c := DimensionTwoDiagonalBraiding(Matrix(K, [[-1,w],[1,-1]]));
> c;
[-1  0  0  0]
[ 0  0  w  0]
[ 0  1  0  0]
[ 0  0  0 -1]

where w is a primitive cubic root of unity. The dimensions of homogeneous components are 1, 2, 2, 2, 2, 2, 1 and the dimension of the algebra is 12.

Better with sparce matrices?

There is a trick to try to gain some speed: use SparseMatrix for the quantum symmetrizer. Here is an alternative code for the function ComputeDimension:

> ComputeDimensionSparseMatrix := function(c, n)
function> if n eq 0 then
function|if> return 1;
function|if> else
function|if> return Rank(SparseMatrix(Symmetrizer(c, n)));
function|if> end if;
function> end function;

In these examples, I cannot find a huge speed improvement, though.

Magma can work with finite-dimensional algebras, but this can be tricky. Let us start with the quaternion algebra $\langle i,j: i^2=j^2=-1, ij=-ji\rangle$. We can introduce this algebra by generators and relations:

> F<a,b> := FreeAlgebra(Rationals(), 2);
> A<i,j> := quo<F|a^2+1,b^2+1,a*b+b*a>;
> i^2;
-1
> j^2;
-1
> i*j;
-j*i
> Dimension(A);
4

But the problem is that we cannot do very much with this presentation: asking for a basis, the center, or the Jacobson radical produces an error message.

As an alternative, we can construct the algebra using its structure constants. Recall that if $A$ is an $n$-dimensional algebra with basis $e_1,\dots,e_n$, its structure constants are the scalars $a_{ijk}$ such that $e_ie_j=\sum_{k=1}^na_{ijk}e_k$ for all $1\leq i,j\leq n$. Let us construct the array of structure constants of the quaternion algebra. For this, let $n=4$, $e_1=1$, $e_2=i$, $e_3=j$ and $e_4=k$. Since $e_2e_1=e_2$ we get that $a_{211}=a_{213}=a_{214}=0$ and $a_{212}=1$. Similarly, since $e_2^2=-e_1$, $a_{221}=-1$ and $a_{222}=a_{223}=a_{224}=0$. In this way we get the structure constants:

> a := [[[ 0 : k in [1..4]] : j in [1..4]] : i in [1..4]];
> a[1][1][1] := 1;
> a[1][2][2] := 1;
> a[1][3][3] := 1;
> a[1][4][4] := 1;
> a[2][1][2] := 1;
> a[2][2][1] := -1;
> a[2][3][4] := 1;
> a[2][4][3] := -1;
> a[3][1][3] := 1;
> a[3][2][4] := -1;
> a[3][3][1] := -1;
> a[3][4][2] := 1;
> a[4][1][4] := 1;
> a[4][2][3] := 1;
> a[4][3][2] := -1;
> a[4][4][1] := -1;

Now we can construct the quaternion algebra as the algebra with that particular structure constants:

> A := Algebra< Rationals(), 4 | a >;
> Dimension(A);
4
> Basis(A);
[ (1 0 0 0), (0 1 0 0), (0 0 1 0), (0 0 0 1) ]
> JacobsonRadical(A);
Algebra of dimension 0 with base ring Rational Field
> Center(A);
Algebra of dimension 1 with base ring Rational Field
> IsSimple(A);
true

Of course, we could have done this:

> A<i,j> := QuaternionAlgebra<Rationals()|-1, -1>;
> Basis(A);
[ 1, i, j, k ]
> Center(A);
Associative Algebra of dimension 1 with base ring Rational Field
> JacobsonRadical(A);
Associative Algebra of dimension 0 with base ring Rational Field
> IsSimple(A);
true

In Magma, vectors are row vectors and permutation matrices act on the right. For a permutation $\sigma$, the corresponding permutation matrix constructed with PermutationMatrix permutes the coordinates according to $\sigma$. Here is an example corresponding to the permutation $\sigma=(1234)\in\mathbb{S}_5$:

> m := PermutationMatrix(Integers(), [2,3,4,1,5]);
> v := Vector(Integers(), [0,0,0,0,1]);
> v*m;
(0 0 0 0 1)
> w := Vector(Integers(), [1,0,0,0,0]);
> w*m;
(0 1 0 0 0)

Here is another example:

> s := Sym(3)!(1,2);
> m := PermutationMatrix(Integers(), [ x^s : x in [1,2,3] ]);
> m;
[0 1 0]
[1 0 0]
[0 0 1]
> Vector(Integers(), [0,1,0])*m;
(1 0 0)
> Vector(Integers(), [0,0,1])*m;
(0 0 1)

Theorem (Guralnick). There is a group $G$ of order $\leq200$ such that $[G,G]\ne\lbrace [x,y]:x,y\in G\rbrace$ if and only if $n\in\lbrace 96,128,144, 162, 168, 192\rbrace$.

The theorem appeared in [Guralnick, R. Commutators and commutator subgroups. Adv. in Math. 45 (1982), no. 3, 319–330].

Solution. To simplify a bit the presentation, we first define a function that returns the set of commutators of a group:

> SetOfCommutators := function(G)
function> return { (x,y) : x,y in G };
function> end function;

Now we use this function. We send the parameter Warning := false to the function SmallGroups to avoid the warning messages. Otherwise, Magma warns us that the requested calculation involves a huge number of groups:

> time { #G : G in SmallGroups([1..200]:Warning:=false) | 
> not #DerivedSubgroup(G) eq #SetOfCommutators(G) };
{ 96, 128, 144, 162, 168, 192 }
Time: 34.360

The calculation took 34 seconds.

Let us assume we need to iterate over the six automorphisms of the Klein group.

> G := AbelianGroup([2,2]);
> A := AutomorphismGroup(G);

The naive idea doesn’t work. Typing

> { a : a in A };

produces an error message, saying: Iteration is not possible over this object. Thus one cannot directly iterate over automorphism groups. We first need to convert the automorphism group into a structure suitable for iteration. PermutationGroup and FPGroup do not work, and something strange happens with PCGroup. So what we should do? Here is the trick:

> p, P := PermutationRepresentation(A);

Here, p is a (bijective) map from A onto the permutation group P. We can iterate over P, and we need to use the inverse of the map p to identity our elements inside A.

> { x @@ p : x in P };
{
    Automorphism of Abelian Group isomorphic to Z/2 + Z/2
    Defined on 2 generators
    Relations:
        2*G.1 = 0
        2*G.2 = 0 of order 1 which maps:
        G.1 |--> G.1
        G.2 |--> G.2,
    Automorphism of Abelian Group isomorphic to Z/2 + Z/2
    Defined on 2 generators
    Relations:
        2*G.1 = 0
        2*G.2 = 0 which maps:
        G.1 |--> G.1
        G.2 |--> G.1 + G.2,
    Automorphism of Abelian Group isomorphic to Z/2 + Z/2
    Defined on 2 generators
    Relations:
        2*G.1 = 0
        2*G.2 = 0 which maps:
        G.1 |--> G.2
        G.2 |--> G.1,
    Automorphism of Abelian Group isomorphic to Z/2 + Z/2
    Defined on 2 generators
    Relations:
        2*G.1 = 0
        2*G.2 = 0 which maps:
        G.1 |--> G.1 + G.2
        G.2 |--> G.2,
    Automorphism of Abelian Group isomorphic to Z/2 + Z/2
    Defined on 2 generators
    Relations:
        2*G.1 = 0
        2*G.2 = 0 which maps:
        G.1 |--> G.2
        G.2 |--> G.1 + G.2,
    Automorphism of Abelian Group isomorphic to Z/2 + Z/2
    Defined on 2 generators
    Relations:
        2*G.1 = 0
        2*G.2 = 0 which maps:
        G.1 |--> G.1 + G.2
        G.2 |--> G.1
}

To compute Sylow subgroups we have the function SylowSubgroup, but this function returns only one Sylow subgroup. How can we quickly get them all? Here is an answer:

> S3 := Sym(3);
> P := SylowSubgroup(S3,2);
> { P^x : x in S3 };
{
    Permutation group acting on a set of cardinality 3
    Order = 2
        (1, 3),
    Permutation group acting on a set of cardinality 3
    Order = 2
        (1, 2),
    Permutation group acting on a set of cardinality 3
    Order = 2
        (2, 3)
} 

Possibly faster: conjugate the Sylow subgroup computed by each element of a (right) transversal of the Sylow. Here is the code:

> t := Transversal(S3,P);
> { P^x : x in t };
{
    Permutation group acting on a set of cardinality 3
    Order = 2
        (1, 3),
    Permutation group acting on a set of cardinality 3
    Order = 2
        (1, 2),
    Permutation group acting on a set of cardinality 3
    Order = 2
        (2, 3)
}    

Alternatively, we can also use the function Conjugates.

> Conjugates(S3,P);
{
    Permutation group acting on a set of cardinality 3
    Order = 2
        (1, 3),
    Permutation group acting on a set of cardinality 3
    Order = 2
        (1, 2),
    Permutation group acting on a set of cardinality 3
    Order = 2
        (2, 3)
} 

> G := SL(2,5);
> Z := Center(G);
> Q, p := quo< G|Z >;
> GroupName(Q);
A5

Let us compute some preimages. Let us take a random element y of Q, namely

> y := Random(Q);
> y;
(1, 3, 5, 4, 2)
> x := y @@ p;
> x;
[1 0]
[4 1]

How do I get all the preimages of an element $y$? One needs the (right) coset $(\ker p)x$, where $x$ is such that $p(x)=y$. For this, I need to convert my matrix group into a permutation group:

> f, P := PermutationRepresentation(G);

The map f we get is a bijective group homomorphism $SL_2(5)\to P$, where $P$ is a permutation group. The preimage of $y$ has size two, and it is the right coset $(\ker p)x$. Let us compute this:

> N := f(K);
> K := Kernel(p);

Now the preimage is the set

> { Inverse(f)(n*f(x)) : n in N };
{
    [1 0]
    [4 1],

    [4 0]
    [1 4]
}

C2 := CyclicGroup(2);;
C4 := CyclicGroup(4);;
G, a, b := DirectProduct(C2,C4);

The group G is C2*C4, and the variable a is the following list:

[
    Mapping from: GrpPerm: C2 to GrpPerm: G,
    Mapping from: GrpPerm: C4 to GrpPerm: G
]
> b;
[
    Mapping from: GrpPerm: G to GrpPerm: C2,
    Mapping from: GrpPerm: G to GrpPerm: C4
]

We can also send a list of groups to the function DirectProduct. Here is an example:

G := DirectProduct([C2,C4,C2,C2]);

Solution. An exercise in elementary group theory states that every group of order 12 is a semidirect product of a group of order three and a group of order four. The groups of order three are isomorphic to $C_3$, and the groups of order four are isomorphic to $C_4$ or $C_2\times C_2$. We need to know how $C_3$ acts by automorphisms on $C_4$ and $C_2\times C_2$, and how $C_4$ and $C_2\times C_2$ act by automorphism on $C_3$.

Case 1.

We first start with the group $(C_2\times C_2)\rtimes C_3$. We need the actions by automorphism of $C_3$ on $C_2\times C_2$, that is the group homomorphisms $C_3\to \operatorname{Aut}(C_2\times C_2)$.

> C2xC2<a,b> := AbelianGroup([2,2]);
> C3<g> := CyclicGroup(3);
> A := AutomorphismGroup(C2xC2);

We cannot iterate over an automorphism group. Thus we construct a permutation representation P of A.

> p, P := PermutationRepresentation(A);

Now we construct a list with all the six maps $C_3\to \operatorname{Aut}(C_2\times C_2)$; not all are group homomorphisms.

> maps := [ hom<C3->A | <g,Inverse(p)(P!x)>> : x in P ];

Here, Inverse(p)(P!x) is the automorphism of $C_2\times C_2$ corresponding to the permutation x by the bijection p. We crucial fact here is that we cannot iterate over A but we can do it over P.

Now to get all semidirect products of the form $(C_2\times C_2)\rtimes C_3$ we need to run over all homomorphisms in the list maps. However, we can’t use the function IsHomomorphism for our maps. Thus we need our function to test whether a map is a homomorphism:

> is_homomorphism := function(f)
function> local dom, x, y;
function> dom := Domain(f);
function> for x in dom do
function|for> for y in dom do
function|for|for> if not (f(x*y) eq f(x)*f(y)) then
function|for|for|if> return false;
function|for|for|if> end if;
function|for|for> end for;
function|for> end for;
function> return true;
function> end function;

This function is rather naive, but is more than enough for our purposes. So let us use it. The code

> for f in maps do
for> if is_homomorphism(f) then
for|if> G := SemidirectProduct(C2xC2, C3, f);
for|if> print GroupName(G);
for|if> end if;
for> end for;
C2*C6
A4
A4

Case 2

What about semidirect products of the form $C_4\rtimes C_3$? In this case, we will only get the cyclic group of order twelve.

> C3<g> := AbelianGroup([3]);
> C4 := AbelianGroup([4]);
> A := AutomorphismGroup(C4);
> p, P := PermutationRepresentation(A);
> maps := [ hom< C3->A | <g,Inverse(p)(P!x)> > : x in P ];

Now we need to use the function is_homomorphism we constructed before and we are done. The code

> { GroupName(SemidirectProduct(C4,C3,f)) : f in maps | is_homomorphism(f) };
{ C12 }

Case 3

We now construct the groups of the form $C_3\rtimes C_4$. We now that $\operatorname{Aut}(C_3)\simeq C_2$. So there is only one non-trivial automorphism of $C_3$, namely $C_3\to C_3$, $x\mapsto -x$ (if the additive notation is used).

> C4<g> := AbelianGroup([4]);
> C3 := AbelianGroup([3]);
> A<a> := AutomorphismGroup(C3);

Note that our a is the automorphism $x\mapsto -x$ of $C_3$. In fact, the command

> a eq hom<C3->C3|x:->-x>;
true

Now we construct the group homomorphism $C_4\to \operatorname{Aut}(C_3)$ sending the generator g of $C_4$ to the automorphism a:

> f := hom<C4->A|<g,a>>;

We can check that this f is a homomorphism, but we leave this as an exercise. Now we construct the semidirect product and check the structure of the group constructed:

> G := SemidirectProduct(C3,C4,f);
> GroupName(G);
C_3:C_4

This means that our G is isomorphic to a semidirect product of the form $C_3\rtimes C_4$.

Case 4

There is one case left, namely the semidirect products of the form $C_3\rtimes (C_2\times C_2)$. Assume that $C_2\times C_2=\langle a,b\rangle$. Let us first construct the groups:

> C2xC2<a,b> := AbelianGroup([2,2]);
> C3 := AbelianGroup([3]);
> A := AutomorphismGroup(C3);

Thus we know that $\operatorname{Aut}(C_3)=\{\operatorname{id},\alpha\}$. There are four possible homomorphisms $C_2\times C_2\to \operatorname{Aut}(C_3)$, as the generator $a$ and $b$ can be mapped independently to either the identity or $\alpha$, Again, we use a permutation representation to be able to iterate over an automorphism group:

> p, P := PermutationRepresentation(A);
> maps := [ hom< C2xC2->A | <a,Inverse(p)(P!x)>, <b,Inverse(p)(P!y)>> : x, y in P ];

Now we run over maps and construct the corresponding semidirect products. The code

> { GroupName(SemidirectProduct(C3,C2xC2,f)) : f in maps };
{ D6, C2*C6 } 

Therefore, in this case, we obtain the dihedral group of order twelve, and the direct product $C_2\times C_6$.