15. FpG-modules
  
      |  CompositionSeriesOfFpGModules(M)  Inputs an FpG-module M and returns a list of FpG-modules that constitute a composition series for M.                                                                                                                                                                                                                                                                                                                                                                                                          | 
      |  DirectSumOfFpGModules(M,N)   DirectSumOfFpGModules([ M[1], M[2], ..., M[k] ]))  Inputs two FpG-modules M and N with common group and characteristic. It returns the direct sum of M and N as an FpG-Module. Alternatively, the function can input a list of FpG-modules with common group G. It returns the direct sum of the list.                                                                                                                                                                                                             | 
      |  FpGModule(A,P)   FpGModule(A,G,p)  Inputs a p-group P and a matrix A whose rows have length a multiple of the order of G. It returns the "canonical" FpG-module generated by the rows of A. A small non-prime-power group G can also be input, provided the characteristic p is entered as a third input variable.                                                                                                                                                                                                                              | 
      |  FpGModuleDualBasis(M)  Inputs an FpG-module M. It returns a record R with two components: -- R.freeModule is the free module FG of rank one. -- R.basis is a list representing an F-basis for the module Hom_FG(M,FG). Each term in the list is a matrix A whose rows are vectors in FG such that M!.generators[i] --> A[i] extends to a module homomorphism M --> FG.                                                                                                                                                                          | 
      |  FpGModuleHomomorphism(M,N,A)   FpGModuleHomomorphismNC(M,N,A)  Inputs FpG-modules M and N over a common p-group G. Also inputs a list A of vectors in the vector space spanned by N!.matrix. It tests that the function M!.generators[i] --> A[i] extends to a homomorphism of FpG-modules and, if the test is passed, returns the corresponding FpG-module homomorphism. If the test is failed it returns fail. The "NC" version of the function assumes that the input defines a homomorphism and simply returns the FpG-module homomorphism. | 
      |  DesuspensionFpGModule(M,n)  DesuspensionFpGModule(R,n)  Inputs a positive integer n and and FpG-module M. It returns an FpG-module D^nM which is mathematically related to M via an exact sequence 0 --> D^nM --> R_n --> ... --> R_0 --> M --> 0 where R_* is a free resolution. (If G=Group(M) is of prime-power order then the resolution is minimal.) Alternatively, the function can input a positive integer n and at least n terms of a free resolution R of M.                                                                          | 
      |  RadicalOfFpGModule(M)  Inputs an FpG-module M with G a p-group, and returns the Radical of M as an FpG-module. (Ig G is not a p-group then a submodule of the radical is returned.                                                                                                                                                                                                                                                                                                                                                              | 
      |  RadicalSeriesOfFpGModule(M)  Inputs an FpG-module M and returns a list of FpG-modules that constitute the radical series for M.                                                                                                                                                                                                                                                                                                                                                                                                                 | 
      |  GeneratorsOfFpGModule(M)  Inputs an FpG-module M and returns a matrix whose rows correspond to a minimal generating set for M.                                                                                                                                                                                                                                                                                                                                                                                                                  | 
      |  ImageOfFpGModuleHomomorphism(f)  Inputs an FpG-module homomorphism f:M --> N and returns its image f(M) as an FpG-module.                                                                                                                                                                                                                                                                                                                                                                                                                       | 
      |  GroupAlgebraAsFpGModule(G)  Inputs a p-group G and returns its mod p group algebra as an FpG-module.                                                                                                                                                                                                                                                                                                                                                                                                                                            | 
      |  IntersectionOfFpGModules(M,N)  Inputs two FpG-modules M, N arising as submodules in a common free module (FG)^n where G is a finite group and F the field of p-elements. It returns the FpG-module arising as the intersection of M and N.                                                                                                                                                                                                                                                                                                      | 
      |  IsFpGModuleHomomorphismData(M,N,A)  Inputs FpG-modules M and N over a common p-group G. Also inputs a list A of vectors in the vector space spanned by N!.matrix. It returns true if the function M!.generators[i] --> A[i] extends to a homomorphism of FpG-modules. Otherwise it returns false.                                                                                                                                                                                                                                               | 
      |  MaximalSubmoduleOfFpGModule(M)  Inputs an FpG-module M and returns one maximal FpG-submodule of M.                                                                                                                                                                                                                                                                                                                                                                                                                                              | 
      |  MaximalSubmodulesOfFpGModule(M)  Inputs an FpG-module M and returns the list of maximal FpG-submodules of M.                                                                                                                                                                                                                                                                                                                                                                                                                                    | 
      |  MultipleOfFpGModule(w,M)  Inputs an FpG-module M and a list w:=[g_1 , ..., g_t] of elements in the group G=M!.group. The list w can be thought of as representing the element w=g_1 + ... + g_t in the group algebra FG, and the function returns a semi-echelon matrix B which is a basis for the vector subspace wM .                                                                                                                                                                                                                         | 
      |  ProjectedFpGModule(M,k)  Inputs an FpG-module M of ambient dimension n|G|, and an integer k between 1 and n. The module M is a submodule of the free module (FG)^n . Let M_k denote the intersection of M with the last k summands of (FG)^n . The function returns the image of the projection of M_k onto the k-th summand of (FG)^n . This image is returned an FpG-module with ambient dimension |G|.                                                                                                                                       | 
      |  RandomHomomorphismOfFpGModules(M,N)  Inputs two FpG-modules M and N over a common group G. It returns a random matrix A whose rows are vectors in N such that the function M!.generators[i] --> A[i] extends to a homomorphism M --> N of FpG-modules. (There is a problem with this function at present.)                                                                                                                                                                                                                                      | 
      |  Rank(f)  Inputs an FpG-module homomorphism f:M --> N and returns the dimension of the image of f as a vector space over the field F of p elements.                                                                                                                                                                                                                                                                                                                                                                                              | 
      |  SumOfFpGModules(M,N)  Inputs two FpG-modules M, N arising as submodules in a common free module (FG)^n where G is a finite group and F the field of p-elements. It returns the FpG-Module arising as the sum of M and N.                                                                                                                                                                                                                                                                                                                        | 
      |  SumOp(f,g)  Inputs two FpG-module homomorphisms f,g:M --> N with common sorce and common target. It returns the sum f+g:M --> N . (This operation is also available using "+".                                                                                                                                                                                                                                                                                                                                                                  | 
      |  VectorsToFpGModuleWords(M,L)  Inputs an FpG-module M and a list L=[v_1,... ,v_k] of vectors in M. It returns a list L'= [x_1,...,x_k] . Each x_j=[[W_1,G_1],...,[W_t,G_t]] is a list of integer pairs corresponding to an expression of v_j as a word v_j = g_1*w_1 + g_2*w_1 + ... + g_t*w_t where g_i=Elements(M!.group)[G_i] w_i=GeneratorsOfFpGModule(M)[W_i] .                                                                                                                                                                             |