GAP (RepnDecomp) - Chapter 4: Miscellaneous useful functions

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

[MathJax on]

4 Miscellaneous useful functions
4.1 Predicates for representations
4.1-1 IsFiniteGroupLinearRepresentation
4.1-2 IsFiniteGroupPermutationRepresentation
4.2 Efficient summing over groups
4.2-1 GroupSumBSGS
4.3 Space-efficient representation of tensors of matrices
4.3-1 IsTensorProductOfMatricesObj
4.3-2 IsTensorProductPairRep
4.3-3 IsTensorProductKroneckerRep
4.3-4 TensorProductOfMatrices
4.3-5 CharacterOfTensorProductOfRepresentations
4.4 Matrices and homomorphisms
4.4-1 ComposeHomFunction
4.5 Representation theoretic functions
4.5-1 TensorProductRepLists
4.5-2 DirectSumOfRepresentations
4.5-3 DegreeOfRepresentation
4.5-4 PermToLinearRep
4.5-5 IsOrthonormalSet

### 4 Miscellaneous useful functions

#### 4.1 Predicates for representations

##### 4.1-1 IsFiniteGroupLinearRepresentation

`‣ 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.

##### 4.1-2 IsFiniteGroupPermutationRepresentation

`‣ IsFiniteGroupPermutationRepresentation`( rho ) | ( attribute )

Returns: true or false

Tells you if rho is a homomorphism from a finite group to a permutation group.

#### 4.2 Efficient summing over groups

##### 4.2-1 GroupSumBSGS

`‣ 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.

#### 4.3 Space-efficient representation of tensors of matrices

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.

##### 4.3-1 IsTensorProductOfMatricesObj

`‣ 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.

##### 4.3-2 IsTensorProductPairRep

`‣ 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.

##### 4.3-3 IsTensorProductKroneckerRep

`‣ IsTensorProductKroneckerRep`( arg ) | ( filter )

Returns: `true` or `false`

More convenient constructor for a tensor product (automatically handles family)

##### 4.3-4 TensorProductOfMatrices

`‣ TensorProductOfMatrices`( arg ) | ( function )

This uses the multiplicativity of characters when taking tensor products to avoid having to compute the trace of a big matrix.

##### 4.3-5 CharacterOfTensorProductOfRepresentations

`‣ CharacterOfTensorProductOfRepresentations`( arg ) | ( function )

#### 4.4 Matrices and homomorphisms

##### 4.4-1 ComposeHomFunction

`‣ 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.

#### 4.5 Representation theoretic functions

##### 4.5-1 TensorProductRepLists

`‣ 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.

##### 4.5-2 DirectSumOfRepresentations

`‣ DirectSumOfRepresentations`( list ) | ( function )

Returns: Direct sum of the list of representations list

##### 4.5-3 DegreeOfRepresentation

`‣ 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.

##### 4.5-4 PermToLinearRep

`‣ PermToLinearRep`( rho ) | ( function )

Returns: Linear representation \rho isomorphic to the permutation representation rho.

##### 4.5-5 IsOrthonormalSet

`‣ IsOrthonormalSet`( S, prod ) | ( function )

Returns: Whether S is an orthonormal set with respect to the inner product prod.

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

generated by GAPDoc2HTML