‣ IsFiniteGroupLinearRepresentation( rho ) | ( attribute ) |
Returns: true or false
Tells you if rho is a linear representation of a finite group. The algorithms implemented in this package work on these homomorphisms only.
‣ IsFiniteGroupPermutationRepresentation( rho ) | ( attribute ) |
Returns: true or false
Tells you if rho is a homomorphism from a finite group to a permutation group.
‣ GroupSumBSGS( G, summand ) | ( function ) |
Returns: \sum_{g \in G} \mbox{summand}(g)
Uses a basic stabiliser chain for G to compute the sum described above. This trick requires summand to be a function (in the GAP sense) that defines a monoid homomorphism (in the mathematical sense). The computation of the stabiliser chain assumes G is a group. More precisely, if we have the basic stabiliser chain:
\{1\} = G_1 \leq \ldots \leq G_n = G
We traverse the chain from G_1 to G_n, using the previous sum G_{i-1} to build the sum G_i. We do this by using the fact that (writing f for summand)
\sum_{g \in G_i} f(g) = \sum_{r_j} \left(\sum_{h \in G_{i-1}} f(h)\right) f(r_j)
where the r_j are right coset representatives of G_{i-1} in G_i. The condition on summand is satisfied if, for example, it is a linear representation of a group G.
Suppose we have representations of G, \rho and \tau, with degree n and m. If we would like to construct the tensor product representation of G, \rho \otimes \tau, the usual way to do it would be to take the Kronecker product of the matrices. This means we now have to store very large nm \times nm matrices for each generator of G. This can be avoided by storing the tensor of matrices as pairs, essentially storing A \otimes B as a pair (A,B) and implementing group operations on top of these, along with some representation-theoretic functions. It is only possible to guarantee an economical representation for pure tensors, i.e. matrices of the form A \otimes B. These are closed under group operations, so it is natural to define a group structure.
‣ IsTensorProductOfMatricesObj( arg ) | ( filter ) |
Returns: true or false
Position i in this representation stores the matrix A_i in the tensor product A_1 \otimes A_2.
‣ IsTensorProductPairRep( arg ) | ( filter ) |
Returns: true or false
Position 1 stores the full Kronecker product of the matrices, this is very space inefficient and supposed to be used as a last resort.
‣ IsTensorProductKroneckerRep( arg ) | ( filter ) |
Returns: true or false
More convenient constructor for a tensor product (automatically handles family)
‣ TensorProductOfMatrices( arg ) | ( function ) |
This uses the multiplicativity of characters when taking tensor products to avoid having to compute the trace of a big matrix.
‣ CharacterOfTensorProductOfRepresentations( arg ) | ( function ) |
‣ ComposeHomFunction( hom, func ) | ( function ) |
Returns: Homomorphism g given by g(x) = func(hom(x)).
This is mainly for convenience, since it handles all GAP accounting issues regarding the range, ByImages vs ByFunction, etc.
‣ TensorProductRepLists( list1, list2 ) | ( function ) |
Returns: All possible tensor products given by \rho \otimes \tau where \rho : G \to \mbox{GL}(V) is taken from list1 and \tau : H \to \mbox{GL}(W) is taken from list2. The result is then a list of representations of G \times H.
‣ DirectSumOfRepresentations( list ) | ( function ) |
Returns: Direct sum of the list of representations list
‣ DegreeOfRepresentation( rho ) | ( function ) |
Returns: Degree of the representation rho. That is, \mbox{Tr}(\rho(e_G)), where e_G is the identity of the group G that rho has as domain.
‣ PermToLinearRep( rho ) | ( function ) |
Returns: Linear representation \rho isomorphic to the permutation representation rho.
‣ IsOrthonormalSet( S, prod ) | ( function ) |
Returns: Whether S is an orthonormal set with respect to the inner product prod.
generated by GAPDoc2HTML