<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<!-- %% -->
<!-- %W  meataxe.tex                 GAP documentation        Alexander Hulpke -->
<!-- %% -->
<!-- %% -->
<!-- %Y  Copyright 1997,  Lehrstuhl D für Mathematik,  RWTH Aachen,   Germany -->
<!-- %% -->
<!-- %%  This file contains a description of the MeatAxe functions. -->
<!-- %% -->
<Chapter Label="The MeatAxe">
<Heading>The MeatAxe</Heading>

The MeatAxe <Cite Key="Par84"/> is a tool for the examination of submodules of a
group algebra. It is a basic tool for the examination of group actions on
finite-dimensional modules.
<P/>
&GAP; uses the improved MeatAxe of Derek Holt and Sarah Rees, and
also incorporates further improvements of Ivanyos and Lux.
<P/>
Please note that, consistently with the convention for group actions, the action of the &GAP; MeatAxe is always that of matrices
on row vectors by multiplication on the right. If you want to investigate
left modules you will have to transpose the matrices.


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="MeatAxe Modules">
<Heading>MeatAxe Modules</Heading>

<ManSection>
<Heading>GModuleByMats</Heading>
<Func Name="GModuleByMats" Arg='gens, field'
 Label="for generators and a field"/>
<Func Name="GModuleByMats" Arg='emptygens, dim, field'
 Label="for empty list, the dimension, and a field"/>

<Description>
creates a MeatAxe module over <A>field</A> from a list of invertible matrices
<A>gens</A> which reflect a group's action. If the list of generators is empty,
the dimension must be given as second argument.
<P/>
MeatAxe routines are on a level with Gaussian elimination. Therefore they do
not deal with &GAP; modules but essentially with lists of matrices. For the
MeatAxe, a module is a record with components
<P/>
<List>
<Mark><C>generators</C></Mark>
<Item>
   A list of matrices which represent a group operation on a
   finite dimensional row vector space.
</Item>
<Mark><C>dimension</C></Mark>
<Item>
   The dimension of the vector space (this is the common length of
   the row vectors (see&nbsp;<Ref Attr="DimensionOfVectors"/>)).
</Item>
<Mark><C>field</C></Mark>
<Item>
   The field over which the vector space is defined.
</Item>
</List>
<P/>
Once a module has been created its entries may not be changed. A MeatAxe may
create a new component <A>NameOfMeatAxe</A> in which it can store private
information. By a MeatAxe <Q>submodule</Q> or <Q>factor module</Q> we denote
actually the <E>induced action</E> on the submodule, respectively factor module.
Therefore the submodules or factor modules are again MeatAxe modules. The
arrangement of <C>generators</C> is guaranteed to be the same for the induced
modules, but to obtain the complete relation to the original module, the
bases used are needed as well.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Module Constructions">
<Heading>Module Constructions</Heading>

<ManSection>
<Heading>NaturalGModule</Heading>
<Func Name="NaturalGModule" Arg='group[, field]' Label="for matrix group and a field"/>
<Description>
creates a MeatAxe module over <A>field</A> from the generators of the matrix
group <A>group</A>. If <A>field</A> is not provided then the value returned by
<Ref Attr="DefaultFieldOfMatrixGroup"/> is used instead.
</Description>
</ManSection>

<ManSection>
<Func Name="PermutationGModule" Arg='G, F'/>

<Description>
Called with a permutation group <A>G</A> and a field <A>F</A> (<A>F</A> may be infinite),
<Ref Func="PermutationGModule"/> returns the natural permutation module
<M>M</M> over <A>F</A>
for the group of permutation matrices that acts on the canonical basis of
<M>M</M> in the same way as <A>G</A> acts on the points up to its largest
moved point (see&nbsp;<Ref Attr="LargestMovedPoint" Label="for a list or collection of permutations"/>).
</Description>
</ManSection>

<ManSection>
<Func Name="TrivialGModule" Arg='G, F'/>

<Description>
Called with a group <A>G</A> and a field <A>F</A> (<A>F</A> may be infinite),
<Ref Func="TrivialGModule"/> returns the trivial module over <A>F</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="TensorProductGModule" Arg='m1, m2'/>

<Description>
<Ref Func="TensorProductGModule"/> calculates the tensor product
of the modules <A>m1</A> and <A>m2</A>.
They are assumed to be modules over the same algebra so, in particular,
they should have the same number of generators.
</Description>
</ManSection>

<ManSection>
<Func Name="DirectSumGModule" Arg='m1, m2'/>

<Description>
<Ref Func="DirectSumGModule"/> calculates the direct sum
of the modules <A>m1</A> and <A>m2</A>.
They are assumed to be modules over the same algebra so, in particular,
they should have the same number of generators.
</Description>
</ManSection>

<ManSection>
<Func Name="WedgeGModule" Arg='module'/>

<Description>
<Ref Func="WedgeGModule"/> calculates the wedge product of a <A>G</A>-module.
That is the action on antisymmetric tensors.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Selecting a Different MeatAxe">
<Heading>Selecting a Different MeatAxe</Heading>

<ManSection>
<Var Name="MTX"/>

<Description>
All MeatAxe routines are accessed via the global variable <Ref Var="MTX"/>,
which is a record whose components hold the various functions.
It is possible to have several implementations of a MeatAxe available.
Each MeatAxe represents its routines in an own global variable and assigning
<Ref Var="MTX"/> to this variable selects the corresponding MeatAxe.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Accessing a Module">
<Heading>Accessing a Module</Heading>

Even though a MeatAxe module is a record, its components should never be
accessed outside of MeatAxe functions. Instead the following operations
should be used:

<ManSection>
<Func Name="MTX.Generators" Arg='module'/>

<Description>
returns a list of matrix generators of <A>module</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.Dimension" Arg='module'/>

<Description>
returns the dimension in which the matrices act.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.Field" Arg='module'/>

<Description>
returns the field over which <A>module</A> is defined.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Irreducibility Tests">
<Heading>Irreducibility Tests</Heading>

<ManSection>
<Func Name="MTX.IsIrreducible" Arg='module'/>

<Description>
tests whether the module <A>module</A> is irreducible (i.e. contains no proper
submodules.)
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.IsAbsolutelyIrreducible" Arg='module'/>

<Description>
A module is absolutely irreducible if it remains irreducible over the
algebraic closure of the field.
(Formally: If the tensor product <M>L \otimes_K M</M> is irreducible
where <M>M</M> is the module defined over <M>K</M> and <M>L</M> is the
algebraic closure of <M>K</M>.)
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.DegreeSplittingField" Arg='module'/>

<Description>
returns the degree of the splitting field as extension of the prime field.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Decomposition of modules">
<Heading>Decomposition of modules</Heading>

A module is <E>decomposable</E> if it can be written as the direct sum of two
proper submodules (and <E>indecomposable</E> if not). Obviously every finite
dimensional module is a direct sum of its indecomposable parts.
The <E>homogeneous components</E> of a module are the direct sums of isomorphic
indecomposable components. They are uniquely determined.
<P/>
<ManSection>
<Func Name="MTX.IsIndecomposable" Arg='module'/>

<Description>
returns whether <A>module</A> is indecomposable.
</Description>
</ManSection>
<P/>
<ManSection>
<Func Name="MTX.Indecomposition" Arg='module'/>

<Description>
returns a decomposition of <A>module</A> as a direct sum of indecomposable
modules. It returns a list, each entry is a list of form [<A>B</A>,<A>ind</A>] where
<A>B</A> is a list of basis vectors for the indecomposable component and <A>ind</A>
the induced module action on this component. (Such a decomposition is not
unique.)
</Description>
</ManSection>
<P/>
<ManSection>
<Func Name="MTX.HomogeneousComponents" Arg='module'/>

<Description>
computes the homogeneous components of <A>module</A> given as sums of
indecomposable components. The function returns a list, each entry of which
is a record corresponding to one isomorphism type of indecomposable
components.
The record has the following components.
<P/>
<List>
<Mark><C>indices</C></Mark>
<Item>
  the index numbers of the indecomposable components,
  as given by <Ref Func="MTX.Indecomposition"/>,
  that are in the homogeneous component,
</Item>
<Mark><C>component</C></Mark>
<Item>
  one of the indecomposable components,
</Item>
<Mark><C>images</C></Mark>
<Item>
  a list of the remaining indecomposable components,
  each given as a record with the components
  <C>component</C> (the component itself) and
  <C>isomorphism</C> (an isomorphism from the defining component to this one).
</Item>
</List>
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Finding Submodules">
<Heading>Finding Submodules</Heading>

<ManSection>
<Func Name="MTX.SubmoduleGModule" Arg='module, subspace'/>
<Func Name="MTX.SubGModule" Arg='module, subspace'/>

<Description>
<A>subspace</A> should be a subspace of (or a vector in) the underlying vector
space of <A>module</A> i.e. the full row space of the same dimension and over
the same field as <A>module</A>. A normalized basis of the submodule of
<A>module</A> generated by <A>subspace</A> is returned.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.ProperSubmoduleBasis" Arg='module'/>

<Description>
returns the basis of a proper submodule of <A>module</A> and <K>fail</K> if no proper
submodule exists.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasesSubmodules" Arg='module'/>

<Description>
returns a list containing a basis for every submodule.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasesMinimalSubmodules" Arg='module'/>

<Description>
returns a list of bases of all minimal submodules.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasesMaximalSubmodules" Arg='module'/>

<Description>
returns a list of bases of all maximal submodules.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasisRadical" Arg='module'/>

<Description>
returns a basis of the radical of <A>module</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasisSocle" Arg='module'/>

<Description>
returns a basis of the socle of <A>module</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasesMinimalSupermodules" Arg='module, sub'/>

<Description>
returns a list of bases of all minimal supermodules of the submodule given by
the basis <A>sub</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasesCompositionSeries" Arg='module'/>

<Description>
returns a list of bases of submodules in a composition series in ascending
order.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.CompositionFactors" Arg='module'/>

<Description>
returns a list of composition factors of <A>module</A> in ascending order.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.CollectedFactors" Arg='module'/>

<Description>
returns a list giving all irreducible composition factors with their
frequencies.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Induced Actions">
<Heading>Induced Actions</Heading>

<ManSection>
<Func Name="MTX.NormedBasisAndBaseChange" Arg='sub'/>

<Description>
returns a list <C>[<A>bas</A>, <A>change</A> ]</C> where <A>bas</A> is a
normed basis (i.e. in echelon form with pivots normed to 1) for <A>sub</A>
and <A>change</A> is the base change from <A>bas</A> to <A>sub</A>
(the basis vectors of <A>bas</A> expressed in coefficients for <A>sub</A>).
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.InducedActionSubmodule" Arg='module, sub'/>
<Func Name="MTX.InducedActionSubmoduleNB" Arg='module, sub'/>

<Description>
creates a new module corresponding to the action of <A>module</A> on
the non-trivial submodule
<A>sub</A>.
In the <C>NB</C> version the basis <A>sub</A> must be normed.
(That is it must be in echelon form with pivots normed to 1,
see&nbsp;<Ref Func="MTX.NormedBasisAndBaseChange"/>.)
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.InducedActionFactorModule" Arg='module, sub[, compl]'/>

<Description>
creates a new module corresponding to the action of <A>module</A> on the
factor of the proper submodule <A>sub</A>. If <A>compl</A> is given, it has to be a basis of a
(vector space-)complement of <A>sub</A>. The action then will correspond to
<A>compl</A>.
<P/>
The basis <A>sub</A> has to be given in normed form. (That is it must be in
echelon form with pivots normed to 1,
see&nbsp;<Ref Func="MTX.NormedBasisAndBaseChange"/>)
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.InducedActionSubMatrix" Arg='mat, sub'/>
<Func Name="MTX.InducedActionSubMatrixNB" Arg='mat, sub'/>
<Func Name="MTX.InducedActionFactorMatrix" Arg='mat, sub[, compl]'/>

<Description>
work the same way as the above functions for modules, but take as input only
a single matrix.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.InducedAction" Arg='module, sub[, type]'/>

<Description>
Computes induced actions on submodules or factor modules and also returns the
corresponding bases. The action taken is binary encoded in <A>type</A>:
<C>1</C> stands for subspace action,
<C>2</C> for factor action,
and <C>4</C> for action of the full module on a subspace adapted basis.
The routine returns the computed results in a list in sequence
(<A>sub</A>,<A>quot</A>,<A>both</A>,<A>basis</A>)
where <A>basis</A> is a basis for the whole space,
extending <A>sub</A>. (Actions which are not computed are omitted, so the
returned list may be shorter.)
If no <A>type</A> is given, it is assumed to be <C>7</C>.
The basis given in <A>sub</A> must be normed!
<P/>
All these routines return <K>fail</K> if <A>sub</A> is not a proper subspace.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Module Homomorphisms">
<Heading>Module Homomorphisms</Heading>

<ManSection>
<Func Name="MTX.BasisModuleHomomorphisms" Arg='module1, module2'/>

<Description>
returns a basis of all module homomorphisms from <A>module1</A> to
<A>module2</A>.
Homomorphisms are by matrices, whose rows give the images of the
standard basis vectors of <A>module1</A> in the standard basis of
<A>module2</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.BasisModuleEndomorphisms" Arg='module'/>

<Description>
returns a basis of all module homomorphisms from <A>module</A> to <A>module</A>.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.IsomorphismModules" Arg='module1, module2'/>

<Description>
If <A>module1</A> and <A>module2</A> are isomorphic modules,
this function returns an isomorphism from <A>module1</A> to <A>module2</A>
in form of a matrix.
It returns <K>fail</K> if the modules are not isomorphic.
</Description>
</ManSection>

<ManSection>
<Func Name="MTX.ModuleAutomorphisms" Arg='module'/>

<Description>
returns the module automorphisms of <A>module</A> (the set of all isomorphisms
from <A>module</A> to itself) as a matrix group.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Module Homomorphisms for irreducible modules">
<Heading>Module Homomorphisms for irreducible modules</Heading>

The following are lower-level functions that provide homomorphism
functionality for irreducible modules. Generic code should use the functions
in Section <Ref Sect="Module Homomorphisms"/> instead.

<ManSection>
<Func Name="MTX.IsEquivalent" Arg='module1, module2'/>

<Description>
tests two irreducible modules for equivalence.
</Description>
</ManSection>


<ManSection>
<Func Name="MTX.IsomorphismIrred" Arg='module1, module2'/>

<Description>
returns an isomorphism from <A>module1</A> to <A>module2</A> (if one exists),
and <K>fail</K> otherwise. It requires that one of the modules is known to be
irreducible. It implicitly assumes that the same group is acting, otherwise
the results are unpredictable.
The isomorphism is given by a matrix <M>M</M>, whose rows give the images of
the standard basis vectors of <A>module1</A> in the standard basis of
<A>module2</A>.
That is, conjugation of the generators of <A>module2</A> with <M>M</M> yields
the generators of <A>module1</A>.
</Description>
</ManSection>


<ManSection>
<Func Name="MTX.Homomorphism" Arg='module1, module2, mat'/>

<Description>
<A>mat</A> should be a <A>dim1</A> <M>\times</M> <A>dim2</A> matrix
defining a homomorphism from <A>module1</A> to <A>module2</A>.
This function verifies that <A>mat</A>
really does define a module homomorphism, and then returns the
corresponding homomorphism between the underlying row spaces of the
modules. This can be used for computing kernels, images and pre-images.
</Description>
</ManSection>


<ManSection>
<Func Name="MTX.Homomorphisms" Arg='module1, module2'/>

<Description>
returns a basis of the space of all homomorphisms from the irreducible module
<A>module1</A> to <A>module2</A>.
</Description>
</ManSection>


<ManSection>
<Func Name="MTX.Distinguish" Arg='cf, nr'/>

<Description>
Let <A>cf</A> be the output of <Ref Func="MTX.CollectedFactors"/>.
This routine tries to find a group algebra element that has nullity zero
on all composition factors except number <A>nr</A>.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="meataxe:Invariant Forms">
<Heading>MeatAxe Functionality for Invariant Forms</Heading>

The functions in this section can only be applied to an absolutely irreducible
MeatAxe module.

<ManSection>
<Func Name="MTX.InvariantBilinearForm" Arg='module'/>

<Description>
returns an invariant bilinear form, which may be symmetric or anti-symmetric,
of <A>module</A>, or <K>fail</K> if no such form exists.
</Description>
</ManSection>


<ManSection>
<Func Name="MTX.InvariantSesquilinearForm" Arg='module'/>

<Description>
returns an invariant hermitian (= self-adjoint) sesquilinear form of
<A>module</A>,
which must be defined over a finite field whose order is a square,
or <K>fail</K> if no such form exists.
</Description>
</ManSection>


<#Include Label="MTX.InvariantQuadraticForm">


<ManSection>
<Func Name="MTX.BasisInOrbit" Arg='module'/>

<Description>
returns a basis of the underlying vector space of <A>module</A> which is contained
in an orbit of the action of the generators of module on that space.
This is used by <Ref Func="MTX.InvariantQuadraticForm"/> in characteristic 2.
</Description>
</ManSection>


<#Include Label="MTX.OrthogonalSign">

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="The Smash MeatAxe">
<Heading>The Smash MeatAxe</Heading>

The standard MeatAxe provided in the &GAP; library is
based on the MeatAxe in the &GAP;&nbsp;3 package <Package>Smash</Package>,
originally written by Derek Holt and Sarah Rees <Cite Key="HR94"/>.
It is accessible via the variable <C>SMTX</C> to which <Ref Var="MTX"/>
is assigned by default.
For the sake of completeness the remaining sections document more technical
functions of this MeatAxe.

<ManSection>
<Func Name="SMTX.RandomIrreducibleSubGModule" Arg='module'/>

<Description>
returns the module action on a random irreducible submodule.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.GoodElementGModule" Arg='module'/>

<Description>
finds an element with minimal possible nullspace dimension if <A>module</A>
is known to be irreducible.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.SortHomGModule" Arg='module1, module2, homs'/>

<Description>
Function to sort the output of <C>Homomorphisms</C>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.MinimalSubGModules" Arg='module1, module2[, max]'/>

<Description>
returns (at most <A>max</A>) bases of submodules of <A>module2</A> which are
isomorphic to the irreducible module  <A>module1</A>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.Setter" Arg='string'/>

<Description>
returns a setter function for the component <C>smashMeataxe.(string)</C>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.Getter" Arg='string'/>

<Description>
returns a getter function for the component <C>smashMeataxe.(string)</C>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.IrreducibilityTest" Arg='module'/>

<Description>
Tests for irreducibility and sets a subbasis if reducible. It neither sets
an irreducibility flag, nor tests it. Thus the routine also can simply be
called to obtain a random submodule.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AbsoluteIrreducibilityTest" Arg='module'/>

<Description>
Tests for absolute irreducibility and sets splitting field degree. It
neither sets an absolute irreducibility flag, nor tests it.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.MinimalSubGModule" Arg='module, cf, nr'/>

<Description>
returns the basis of a minimal submodule of <A>module</A> containing the
indicated composition factor. It assumes <C>Distinguish</C> has been called
already.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.MatrixSum" Arg='matrices1, matrices2'/>

<Description>
creates the direct sum of two matrix lists.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.CompleteBasis" Arg='module, pbasis'/>

<Description>
extends the partial basis <A>pbasis</A> to a basis of the full space
by action of <A>module</A>. It returns whether it succeeded.
</Description>
</ManSection>

</Section>


<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="Smash MeatAxe Flags">
<Heading>Smash MeatAxe Flags</Heading>

The following getter routines access internal flags. For each routine, the
appropriate setter's name is prefixed with <C>Set</C>.

<ManSection>
<Func Name="SMTX.Subbasis" Arg='module'/>

<Description>
Basis of a submodule.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AlgEl" Arg='module'/>

<Description>
list <C>[newgens,coefflist]</C> giving an algebra element used for chopping.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AlgElMat" Arg='module'/>

<Description>
matrix of <Ref Func="SMTX.AlgEl"/>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AlgElCharPol" Arg='module'/>

<Description>
minimal polynomial of <Ref Func="SMTX.AlgEl"/>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AlgElCharPolFac" Arg='module'/>

<Description>
uses factor of <Ref Func="SMTX.AlgEl"/>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AlgElNullspaceVec" Arg='module'/>

<Description>
nullspace of the matrix evaluated under this factor.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.AlgElNullspaceDimension" Arg='module'/>

<Description>
dimension of the nullspace.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.CentMat" Arg='module'/>

<Description>
matrix centralising all generators which is computed as
a byproduct of <Ref Func="SMTX.AbsoluteIrreducibilityTest"/>.
</Description>
</ManSection>


<ManSection>
<Func Name="SMTX.CentMatMinPoly" Arg='module'/>

<Description>
minimal polynomial of <Ref Func="SMTX.CentMat"/>.
</Description>
</ManSection>

</Section>
</Chapter>
