GAP (RepnDecomp) - Chapter 2: Isomorphisms between representations

Goto Chapter: Top 1 2 3 4 5 6 Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

2 Isomorphisms between representations
2.1 Finding explicit isomorphisms
2.1-1 LinearRepresentationIsomorphism
2.1-2 LinearRepresentationIsomorphismSlow
2.2 Testing isomorphisms
2.2-1 AreRepsIsomorphic
2.2-2 IsLinearRepresentationIsomorphism

### 2 Isomorphisms between representations

#### 2.1 Finding explicit isomorphisms

##### 2.1-1 LinearRepresentationIsomorphism

`‣ LinearRepresentationIsomorphism`( rho, tau[, rho_cent_basis, tau_cent_basis] ) | ( function )

Returns: A matrix \(A\) or fail

Let \(\rho : G \to GL(V)\) and \(\tau : G \to GL(W)\). If there exists a linear map \(A : V \to W\) such that for all \(g \in G\), \(\tau(g)A = A\rho(g)\), this function returns one such \(A\). \(A\) is the isomorphism between the representations. If the representations are not isomorphic, then fail is returned.

There are three methods that we can use to compute an isomorphism of linear representations, you can select one by passing options to the function.

- `use_kronecker`: Assumes the matrices are small enough that their Kronecker products can fit into memory. Uses `GroupSumBSGS` (4.2-1) and `KroneckerProduct` to compute an element of the fixed subspace of \(\rho \otimes \tau^*\).

- `use_orbit_sum`: Finds an isomorphism by summing orbits of the the action of \(\rho \otimes \tau^*\) on matrices. Note that orbits could be very large, so this could be as bad as summing over the whole group.

- The default, sums over the whole group to compute the projection onto the fixed subspace.

    gap> G := SymmetricGroup(4);;
    gap> irreps := IrreducibleRepresentations(G);;
    gap> # rho and tau are isomorphic - they just have a different block order
    > rho := DirectSumOfRepresentations([irreps[1], irreps[3], irreps[3]]);;
    gap> tau := DirectSumOfRepresentations([irreps[3], irreps[1], irreps[3]]);;
    gap> # tau2 is just tau with a basis change - still isomorphic
    > B := RandomInvertibleMat(5);;
    gap> tau2 := ComposeHomFunction(tau, x -> B^-1 * x * B);;
    gap> # using the default implementation
    > M := LinearRepresentationIsomorphism(rho, tau);;
    gap> IsLinearRepresentationIsomorphism(M, rho, tau);
    true
    gap> M := LinearRepresentationIsomorphism(tau, tau2);;
    gap> IsLinearRepresentationIsomorphism(M, tau, tau2);
    true
    gap> # using the kronecker sum implementation
    > M := LinearRepresentationIsomorphism(tau, tau2 : use_kronecker);;
    gap> IsLinearRepresentationIsomorphism(M, tau, tau2);
    true
    gap> # using the orbit sum implementation
    > M := LinearRepresentationIsomorphism(tau, tau2 : use_orbit_sum);;
    gap> IsLinearRepresentationIsomorphism(M, tau, tau2);
    true
    gap> # two distinct irreps are not isomorphic
    > M := LinearRepresentationIsomorphism(irreps[1], irreps[2]);
    fail

##### 2.1-2 LinearRepresentationIsomorphismSlow

`‣ LinearRepresentationIsomorphismSlow`( rho, tau ) | ( function )

Returns: A matrix \(A\) or fail

Gives the same result as `LinearRepresentationIsomorphism` (2.1-1), but this function uses a simpler method which always involves summing over \(G\), without using `GroupSumBSGS` (4.2-1). This might be useful in some cases if computing a good BSGS is difficult. However, for all cases that have been tested, it is slow (as the name suggests).

    gap> # Following on from the previous example
    > M := LinearRepresentationIsomorphismSlow(rho, tau);;
    gap> IsLinearRepresentationIsomorphism(M, rho, tau);
    true

#### 2.2 Testing isomorphisms

##### 2.2-1 AreRepsIsomorphic

`‣ AreRepsIsomorphic`( rho, tau ) | ( function )

Returns: true if rho and tau are isomorphic as representations, false otherwise.

Since representations of finite groups over \(\mathbb{C}\) are determined by their characters, it is easy to check whether two representations are isomorphic by checking if they have the same character. We try to use characters wherever possible.

    gap> # Following on from the previous examples
    > # Some isomorphic representations
    > AreRepsIsomorphic(rho, tau);
    true
    gap> AreRepsIsomorphic(rho, tau2);
    true
    gap> # rho isn't iso to irreps[1] since rho is irreps[1] plus some other stuff
    > AreRepsIsomorphic(rho, irreps[1]);
    false

##### 2.2-2 IsLinearRepresentationIsomorphism

`‣ IsLinearRepresentationIsomorphism`( A, rho, tau ) | ( function )

Returns: true if rho and tau are isomorphic as as representations with the isomorphism given by the linear map A

This function tests if, for all \(g \in G\), \(A \rho(g) = \tau(g) A\). That is, true is returned iff \(A\) is the intertwining operator taking \(\rho\) to \(\tau\). that:

    gap> # We have already seen this function used heavily in previous examples.
    > # If two representations are isomorphic, the following is always true:
    > IsLinearRepresentationIsomorphism(LinearRepresentationIsomorphism(rho, tau), rho, tau);
    true
    gap> # Note: this test is sensitive to ordering:
    > IsLinearRepresentationIsomorphism(LinearRepresentationIsomorphism(rho, tau), tau, rho);
    false

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 Ind

generated by GAPDoc2HTML