# RepresentationPackage2 R¶

RepresentationPackage2 provides functions for working with modular representations of finite groups and algebra. The routines in this package are created, using ideas of R. Parker, (the meat-Axe) to get smaller representations from bigger ones, i.e. finding sub- and factormodules, or to show, that such the representations are irreducible. Note: most functions are randomized functions of Las Vegas type i.e. every answer is correct, but with small probability the algorithm fails to get an answer.

areEquivalent?: (List Matrix R, List Matrix R) -> Matrix R if R has Field

areEquivalent?(aG0, aG1) calls areEquivalent?(aG0, aG1, true, 25). Note: the choice of 25 was rather arbitrary.

areEquivalent?: (List Matrix R, List Matrix R, Boolean, Integer) -> Matrix R if R has Field

areEquivalent?(aG0, aG1, randomelements, numberOfTries) tests whether the two lists of matrices, all assumed of same square shape, can be simultaneously conjugated by a non-singular matrix. If these matrices represent the same group generators, the representations are equivalent. The algorithm tries numberOfTries times to create elements in the generated algebras in the same fashion. If their ranks differ, they are not equivalent. If an isomorphism is assumed, then the kernel of an element of the first algebra is mapped to the kernel of the corresponding element in the second algebra. Now consider the one-dimensional ones. If they generate the whole space (e.g. irreducibility !) we use standardBasisOfCyclicSubmodule to create the only possible transition matrix. The method checks whether the matrix conjugates all corresponding matrices from aGi. The way to choose the singular matrices is as in meatAxe. If the two representations are equivalent, this routine returns the transformation matrix TM with aG0.i * TM = TM * aG1.i for all i. If the representations are not equivalent, a small 0-matrix is returned. Note: the case with different sets of group generators cannot be handled.

areEquivalent?: (List Matrix R, List Matrix R, Integer) -> Matrix R if R has Field

areEquivalent?(aG0, aG1, numberOfTries) calls areEquivalent?(aG0, aG1, true, 25). Note: the choice of 25 was rather arbitrary.

completeEchelonBasis: Vector Vector R -> Matrix R

completeEchelonBasis(lv) completes the basis lv assumed to be in echelon form of a subspace of R^n (n the length of all the vectors in lv) with unit vectors to a basis of R^n. It is assumed that the argument is not an empty vector and that it is not the basis of the 0-subspace. Note: the rows of the result correspond to the vectors of the basis.

createRandomElement: (List Matrix R, Matrix R) -> Matrix R

createRandomElement(aG, x) creates a random element of the group algebra generated by aG.

cyclicSubmodule: (List Matrix R, Vector R) -> Vector Vector R if R has EuclideanDomain

cyclicSubmodule(lm, v) generates a basis as follows. It is assumed that the size n of the vector equals the number of rows and columns of the matrices. Then the matrices generate a subalgebra, say A, of the algebra of all square matrices of dimension n. V R is an A-module in the natural way. cyclicSubmodule(lm, v) generates the R-Basis of Av as described in section 6 of R. A. Parker's “The Meat-Axe”. Note: in contrast to the description in “The Meat-Axe” and to standardBasisOfCyclicSubmodule the result is in echelon form.

isAbsolutelyIrreducible?: (List Matrix R, Integer) -> Boolean if R has Field

isAbsolutelyIrreducible?(aG, numberOfTries) uses Norton's irreducibility test to check for absolute irreduciblity, assuming if a one-dimensional kernel is found. As no field extension changes create “new” elements in a one-dimensional space, the criterium stays true for every extension. The method looks for one-dimensionals only by creating random elements (no fingerprints) since a run of meatAxe would have proved absolute irreducibility anyway.

isAbsolutelyIrreducible?: List Matrix R -> Boolean if R has Field

isAbsolutelyIrreducible?(aG) calls isAbsolutelyIrreducible?(aG, 25). Note: the choice of 25 was rather arbitrary.

meatAxe: (List Matrix R, Boolean) -> List List Matrix R if R has Field and R has Finite

meatAxe(aG, randomElements) calls meatAxe(aG, false, 6, 7), only using Parker's fingerprints, if randomElemnts is false. If it is true, it calls meatAxe(aG, true, 25, 7), only using random elements. Note: the choice of 25 was rather arbitrary. Also, 7 covers the case of three-dimensional kernels over the field with 2 elements.

meatAxe: (List Matrix R, Boolean, Integer, Integer) -> List List Matrix R if R has Field and R has Finite

meatAxe(aG, randomElements, numberOfTries, maxTests) returns a 2-list of representations as follows. All matrices of argument aG are assumed to be square and of equal size. Then aG generates a subalgebra, say A, of the algebra of all square matrices of dimension n. V R is an A-module in the usual way. meatAxe(aG, numberOfTries, maxTests) creates at most numberOfTries random elements of the algebra, tests them for singularity. If singular, it tries at most maxTests elements of its kernel to generate a proper submodule. If successful, a 2-list is returned: first, a list containing first the list of the representations of the submodule, then a list of the representations of the factor module. Otherwise, if we know that all the kernel is already scanned, Norton's irreducibility test can be used either to prove irreducibility or to find the splitting. If randomElements is false, the first 6 tries use Parker's fingerprints.

meatAxe: (List Matrix R, PositiveInteger) -> List List Matrix R if R has Field and R has Finite

meatAxe(aG, numberOfTries) calls meatAxe(aG, true, numberOfTries, 7). Notes: 7 covers the case of three-dimensional kernels over the field with 2 elements.

meatAxe: List Matrix R -> List List Matrix R if R has Field and R has Finite

meatAxe(aG) calls meatAxe(aG, false, 25, 7) returns a 2-list of representations as follows. All matrices of argument aG are assumed to be square and of equal size. Then aG generates a subalgebra, say A, of the algebra of all square matrices of dimension n. V R is an A-module in the usual way. meatAxe(aG) creates at most 25 random elements of the algebra, tests them for singularity. If singular, it tries at most 7 elements of its kernel to generate a proper submodule. If successful a list which contains first the list of the representations of the submodule, then a list of the representations of the factor module is returned. Otherwise, if we know that all the kernel is already scanned, Norton's irreducibility test can be used either to prove irreducibility or to find the splitting. Notes: the first 6 tries use Parker's fingerprints. Also, 7 covers the case of three-dimensional kernels over the field with 2 elements.

scanOneDimSubspaces: (List Vector R, Integer) -> Vector R if R has Field and R has Finite

scanOneDimSubspaces(basis, n) gives a canonical representative of the n-th one-dimensional subspace of the vector space generated by the elements of basis, all from R^n. The coefficients of the representative are of shape (0, …, 0, 1, *, …, *), ** in ``R``. If the size of ``R`` is ``q``, then there are *(q^n-1)/(q-1) of them. We first reduce n modulo this number, then find the largest i such that +/[q^i for i in 0..i-1] <= n. Subtracting this sum of powers from n results in an i-digit number to basis q. This fills the positions of the stars.

split: (List Matrix R, Vector R) -> List List Matrix R if R has Field

split(aG, vector) returns a subalgebra A of all square matrix of dimension n as a list of list of matrices, generated by the list of matrices aG, where n denotes both the size of vector as well as the dimension of each of the square matrices. V R is an A-module in the natural way. split(aG, vector) then checks whether the cyclic submodule generated by vector is a proper submodule of V R. If successful, it returns a two-element list, which contains first the list of the representations of the submodule, then the list of the representations of the factor module. If the vector generates the whole module, a one-element list of the old representation is given. Note: a later version this should call the other split.

split: (List Matrix R, Vector Vector R) -> List List Matrix R if R has Field

split(aG, submodule) uses a proper submodule of R^n to create the representations of the submodule and of the factor module.

standardBasisOfCyclicSubmodule: (List Matrix R, Vector R) -> Matrix R if R has EuclideanDomain

standardBasisOfCyclicSubmodule(lm, v) returns a matrix as follows. It is assumed that the size n of the vector equals the number of rows and columns of the matrices. Then the matrices generate a subalgebra, say A, of the algebra of all square matrices of dimension n. V R is an A-module in the natural way. standardBasisOfCyclicSubmodule(lm, v) calculates a matrix whose non-zero column vectors are the R-Basis of Av achieved in the way as described in section 6 of R. A. Parker's “The Meat-Axe”. Note: in contrast to cyclicSubmodule, the result is not in echelon form.