<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (HAPprime) - Chapter 5: Internal Function Reference</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
</head>
<body>
<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chapInd.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0.html">Top of Book</a> <a href="chap4.html">Previous Chapter</a> <a href="chapInd.html">Next Chapter</a> </div>
<p><a id="X83FF48297FA959A6" name="X83FF48297FA959A6"></a></p>
<div class="ChapSects"><a href="chap5.html#X83FF48297FA959A6">5 <span class="Heading">Internal Function Reference</span></a>
<div class="ContSect"><span class="nocss"> </span><a href="chap5.html#X821158657C23E8B8">5.1 <span class="Heading">Matrices as g-generators of a row space</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X8074BBDF7F1B4FCE">5.1-1 HAPPRIME_GActMatrixColumns</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7F1FA48C8498A5D1">5.1-2 HAPPRIME_ExpandGeneratingRow</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X822F3ECF7C7DA11D">5.1-3 HAPPRIME_ExpandGeneratingRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X8516846779B75BE1">5.1-4 HAPPRIME_AddGeneratingRowToSemiEchelonBasisDestructive</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7CC19D338471C1A8">5.1-5 HAPPRIME_ReduceVectorDestructive</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X83398A0582D763C3">5.1-6 HAPPRIME_ReduceGeneratorsOfModuleBySemiEchelon</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7FB2C7B47BA6AF03">5.1-7 HAPPRIME_ReduceGeneratorsOfModuleByLeavingOneOut</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7DF367CF7F8B296C">5.1-8 HAPPRIME_DisplayGeneratingRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X79B55E0F7DFC4E3A">5.1-9 HAPPRIME_GeneratingRowsBlockStructure</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X86FCD05B7ACB186E">5.1-10 HAPPRIME_DisplayGeneratingRowsBlocks</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X786D19C380E44CBD">5.1-11 HAPPRIME_IndependentGeneratingRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X872D53737FAD75A7">5.1-12 HAPPRIME_GactFGvector</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X820277CB7D631516">5.1-13 HAPPRIME_CoefficientsOfGeneratingRows</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X83A2564481867869">5.1-14 HAPPRIME_GenerateFromGeneratingRowsCoefficients</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7830397286C3D792">5.1-15 HAPPRIME_RemoveZeroBlocks</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X795D4B5F7C443E4D">5.1-16 HAPPRIME_AddZeroBlocks</a></span>
</div>
<div class="ContSect"><span class="nocss"> </span><a href="chap5.html#X820435E87D83DF34">5.2 <span class="Heading">FG-modules</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7A5176C5844FC765">5.2-1 HAPPRIME_DirectSumForm</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X873AD0187A1C3293">5.2-2 HAPPRIME_PrintModuleDescription</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X870EFB907E2F5A68">5.2-3 HAPPRIME_ModuleGeneratorCoefficients</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7B8650FA84ABBA4B">5.2-4 HAPPRIME_ModuleElementFromGeneratorCoefficients</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7EA258467C8190FB">5.2-5 HAPPRIME_MinimalGeneratorsVectorSpaceGeneratingRowsDestructive</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7ADC06E981BCF3F9">5.2-6 HAPPRIME_IsGroupAndAction</a></span>
</div>
<div class="ContSect"><span class="nocss"> </span><a href="chap5.html#X7C0B125E7D5415B4">5.3 <span class="Heading">Resolutions</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X845662157E4E0C39">5.3-1 HAPPRIME_WordToVector</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7BCD0A1D799AD760">5.3-2 HAPPRIME_VectorToWord</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7C79C3CE822EAE32">5.3-3 HAPPRIME_BoundaryMatrices</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7981D36D840820BE">5.3-4 HAPPRIME_AddNextResolutionBoundaryMapMatNC</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X806027CD82F501C0">5.3-5 HAPPRIMECreateResolutionWithBoundaryMapMatsNC</a></span>
</div>
<div class="ContSect"><span class="nocss"> </span><a href="chap5.html#X7C5563A37D566DA5">5.4 <span class="Heading">Miscellaneous</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X825493137E595851">5.4-1 VersionWithSVN</a></span>
</div>
</div>
<h3>5 <span class="Heading">Internal Function Reference</span></h3>
<p>These are functions that are used internally in <strong class="pkg">HAPprime</strong>. They should not be needed by users of the package, but may be useful to developers and are provided for completeness</p>
<p><a id="X821158657C23E8B8" name="X821158657C23E8B8"></a></p>
<h4>5.1 <span class="Heading">Matrices as g-generators of a row space</span></h4>
<p>Both <code class="keyw">FpGModuleGF</code> and <code class="keyw">FpGModuleHomomorphismGF</code> store a matrix whose rows are g-generators for a module vector space (the module and the homomorphism's image respectively). The internal functions listed here provide common operations for dealing with these matrices.</p>
<p><a id="X8074BBDF7F1B4FCE" name="X8074BBDF7F1B4FCE"></a></p>
<h5>5.1-1 HAPPRIME_GActMatrixColumns</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GActMatrixColumns</code>( <var class="Arg">g, Vt, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>The matrix that results from the applying the group action u=gv to each <em>column</em> vector in the matrix <var class="Arg">Bt</var>. The action is provided by the function <var class="Arg">action</var>, and operates on blocks of size <var class="Arg">actionBlockSize</var>.</p>
<p>A set of vectors are passed as <em>columns</em> of a matrix (i.e. the transpose of the normal <strong class="pkg">GAP</strong> representation). In this way the group action is just a permutation of the rows of the matrix, which is a fast operation.</p>
<p>If the input matrix <var class="Arg">Vt</var> is in a compressed matrix representation, then the returned matrix will also be in compressed matrix representation.</p>
<p><a id="X7F1FA48C8498A5D1" name="X7F1FA48C8498A5D1"></a></p>
<h5>5.1-2 HAPPRIME_ExpandGeneratingRow</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ExpandGeneratingRow</code>( <var class="Arg">gen, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A list of the F-generators for the vector space that correspond to the single g-generator <var class="Arg">gen</var>. This space is formed by multiplying the generator by each element of the group in turn, using the group and action specified in <var class="Arg">groupAndAction</var> (see <code class="keyw">HAPPRIME_ModuleGroupAndAction</code>).</p>
<p><a id="X822F3ECF7C7DA11D" name="X822F3ECF7C7DA11D"></a></p>
<h5>5.1-3 HAPPRIME_ExpandGeneratingRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ExpandGeneratingRows</code>( <var class="Arg">gens, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A list of F-generators for the vector space that corresponds to the set of g-generators <var class="Arg">gens</var>. This space is formed by multiplying each generator by each element of <var class="Arg">G</var> in turn, using the action specified by <var class="Arg">action</var> with blocksize <var class="Arg">actionBlockSize</var>.</p>
<p>If the input generators are [v_1, v_2, ..., v_n] then the returned list is [g_1v_1, g_2v_1, ..., g_1v_2, g_2v_2, ..., g_|G|v_n] In other words, the form of the returned matrix is block-wise, with the expansions of each row given in turn. The returned matrix is |G| times larger than the input <var class="Arg">gens</var></p>
<p>This function is more efficient than repeated use of <code class="keyw">HAPPRIME_ExpandGeneratingRow</code> since it uses the efficient <code class="keyw">HAPPRIME_GActMatrixColumns</code> to perform the group action on the whole set of generating rows at a time.</p>
<p><a id="X8516846779B75BE1" name="X8516846779B75BE1"></a></p>
<h5>5.1-4 HAPPRIME_AddGeneratingRowToSemiEchelonBasisDestructive</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_AddGeneratingRowToSemiEchelonBasisDestructive</code>( <var class="Arg">basis, gen, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This function augments a vector space basis with another generator. It returns a record consisting of two elements: <code class="code">vectors</code>, a set of semi-echelon basis vectors for the vector space spanned by the sum of the input <var class="Arg">basis</var> and all g-multiples of the generating vector <var class="Arg">gen</var>; and <code class="code">heads</code>, a list of the head elements, in the same format as returned by <code class="keyw">SemiEchelonMat</code>. The generator <var class="Arg">gen</var> is expanded according to the group and action specified in the <var class="Arg">groupAndAction</var> record (see <code class="keyw">HAPPRIME_ModuleGroupAndAction</code>).</p>
<p>If the input <var class="Arg">basis</var> is not zero, it is also modified by this function, to be the new basis (i.e. the same as the <code class="code">vectors</code> element of the returned record).</p>
<p><a id="X7CC19D338471C1A8" name="X7CC19D338471C1A8"></a></p>
<h5>5.1-5 HAPPRIME_ReduceVectorDestructive</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ReduceVectorDestructive</code>( <var class="Arg">v, basis, heads</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>Reduces the vector <var class="Arg">v</var> (in-place) using the semi-echelon set of vectors <var class="Arg">basis</var> with heads <var class="Arg">heads</var> (as returned by <code class="keyw">SemiEchelonMat</code>). Returns <code class="keyw">true</code> if the vector is completely reduced to zero, or <code class="keyw">false</code> otherwise.</p>
<p><a id="X83398A0582D763C3" name="X83398A0582D763C3"></a></p>
<h5>5.1-6 HAPPRIME_ReduceGeneratorsOfModuleBySemiEchelon</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ReduceGeneratorsOfModuleBySemiEchelon</code>( <var class="Arg">gens, G, action</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ReduceGeneratorsOfModuleBySemiEchelonDestructive</code>( <var class="Arg">gens, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A subset of the module generators <var class="Arg">gens</var> over the group with action specified in the <var class="Arg">groupAndAction</var> record (see <code class="keyw">HAPPRIME_ModuleGroupAndAction</code>) that will still generate the module.</p>
<p>This gradually expands out the module generators into an F-basis, using that F-basis to reduce the other generators, until the full vector space of the module is spanned. The generators needed to span the space are returned, and should be a small set, although not minimal.</p>
<p>The <code class="keyw">Destructive</code> version of this function will modify the input <var class="Arg">gens</var> parameter. The non-destructive version makes a copy first, so leaves the input arguments unchanged, at the expense of more memory.</p>
<p><a id="X7FB2C7B47BA6AF03" name="X7FB2C7B47BA6AF03"></a></p>
<h5>5.1-7 HAPPRIME_ReduceGeneratorsOfModuleByLeavingOneOut</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ReduceGeneratorsOfModuleByLeavingOneOut</code>( <var class="Arg">gens, GA</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A subset of the module generators <var class="Arg">gens</var> over the group with action specifed in the <var class="Arg">groupAndAction</var> record (see <code class="keyw">HAPPRIME_ModuleGroupAndAction</code>) that will still generate the module.</p>
<p>This tries repeatedly leaving out generators from the list <var class="Arg">gens</var> to find a small subset that still generates the module. If the generators are from the field GF(2), this is guaranteed to be a minimal set of generators.</p>
<p><a id="X7DF367CF7F8B296C" name="X7DF367CF7F8B296C"></a></p>
<h5>5.1-8 HAPPRIME_DisplayGeneratingRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_DisplayGeneratingRows</code>( <var class="Arg">gens, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Displays a set of g-generating rows a human-readable form. The elements of each generating vector are displayed, with each block marked by a separator (since the group action on a module vector will only permute elements within a block).</p>
<p>This function is used by <code class="keyw">Display</code> for both <code class="keyw">FpGModuleGF</code> and <code class="keyw">FpGModuleHomomorphismGF</code>.</p>
<p>NOTE: This is currently only implemented for GF(2)</p>
<table class="example">
<tr><td><pre>
gap> HAPPRIME_DisplayGeneratingRows(
> ModuleGenerators(M), HAPPRIME_ModuleGroupAndAction(M));
[...1..11|........|.......1|........|........]
[........|........|........|.1....11|........]
[........|........|........|........|..1.1.1.]
[........|.1.1..1.|........|........|........]
[........|........|......11|........|........]
[........|........|1......1|........|........]
</pre></td></tr></table>
<p><a id="X79B55E0F7DFC4E3A" name="X79B55E0F7DFC4E3A"></a></p>
<h5>5.1-9 HAPPRIME_GeneratingRowsBlockStructure</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GeneratingRowsBlockStructure</code>( <var class="Arg">gens, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>Returns a matrix detailing the block structure of a set of module generating rows.</p>
<p>The group action on a generator permutes the vector in blocks of length <code class="code">groupAndActionA.actionBlockSize</code>: any block that contains non-zero elements will still contain non-zero elements after the group action; any block that is all zero will remain all zero. This operation returns a matrix giving this block structure: it has a one where the block is non-zero and zero where the block is all zero.</p>
<table class="example">
<tr><td><pre>
gap> b := HAPPRIME_GeneratingRowsBlockStructure(
> ModuleGenerators(M), ModuleActionBlockSize(M));
[ [ 1, 0, 1, 1, 1 ], [ 1, 0, 1, 1, 1 ], [ 0, 1, 1, 1, 1 ], [ 0, 0, 1, 1, 1 ] ]
</pre></td></tr></table>
<p><a id="X86FCD05B7ACB186E" name="X86FCD05B7ACB186E"></a></p>
<h5>5.1-10 HAPPRIME_DisplayGeneratingRowsBlocks</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_DisplayGeneratingRowsBlocks</code>( <var class="Arg">gens, actionBlockSize</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Displays a set of g-generating rows a compact human-readable form. Each generating rows can be divided into blocks of length <var class="Arg">actionBlockSize</var>. The generating rows are displayed in a per-block form: a <code class="keyw">*</code> where the block is non-zero and <code class="keyw">.</code> where the block is all zero.</p>
<p>This function is used by <code class="keyw">DisplayBlocks</code> for both <code class="keyw">FpGModuleGF</code> and <code class="keyw">FpGModuleHomomorphismGF</code>.</p>
<table class="example">
<tr><td><pre>
gap> HAPPRIME_DisplayGeneratingRowsBlocks(
> ModuleGenerators(M), HAPPRIME_ModuleGroupAndAction(M));
[*.*..]
[...*.]
[....*]
[.*...]
[..*..]
[..*..] </pre></td></tr></table>
<p><a id="X786D19C380E44CBD" name="X786D19C380E44CBD"></a></p>
<h5>5.1-11 HAPPRIME_IndependentGeneratingRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_IndependentGeneratingRows</code>( <var class="Arg">blocks</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A list of list of row indices, where each list of indices represent a set of generating rows that are indepndent of the others (i.e. share no blocks). The input is not the set of generating rows, but the block structure of the generating rows as returned by <code class="keyw">HAPPRIME_GeneratingRowsBlockStructure</code>.</p>
<table class="example">
<tr><td><pre>
gap> DisplayBlocks(M);
Module over the group ring of Group( [ f1, f2, f3 ] )
in characteristic 2 with 6 generators in FG^5.
[**...]
[.*...]
[.**..]
[.**..]
[...*.]
[....*]
Generators are in minimal echelon form.
gap> gens := ModuleGenerators(M);;
gap> G := ModuleGroup(M);;
gap> blocks := HAPPRIME_GeneratingRowsBlockStructure(gens, G);
[ [ 1, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 1, 1, 0, 0 ], [ 0, 1, 1, 0, 0 ],
[ 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 1 ] ]
gap> HAPPRIME_IndependentGeneratingRows(blocks);
[ [ 1, 2, 3, 4 ], [ 5 ], [ 6 ] ]
</pre></td></tr></table>
<p><a id="X872D53737FAD75A7" name="X872D53737FAD75A7"></a></p>
<h5>5.1-12 HAPPRIME_GactFGvector</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GactFGvector</code>( <var class="Arg">g, v, MT</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>The vector that is the result of the action u=gv of the group element <var class="Arg">g</var> on a module vector <var class="Arg">v</var> (according to the group multiplication table <var class="Arg">MT</var>.</p>
<p>This operation is the quickest current method for a single vector. To perform the same action on a set of vectors, it is faster to use <a href="chap5.html#X8074BBDF7F1B4FCE"><b>HAPPRIME_GActMatrixColumns</b></a> instead.</p>
<p><a id="X820277CB7D631516" name="X820277CB7D631516"></a></p>
<h5>5.1-13 HAPPRIME_CoefficientsOfGeneratingRows</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRows</code>( <var class="Arg">gens, groupAndAction, v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRows</code>( <var class="Arg">gens, groupAndAction, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRowsDestructive</code>( <var class="Arg">gens, groupAndAction, v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRowsDestructive</code>( <var class="Arg">gens, groupAndAction, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRowsGF</code>( <var class="Arg">gens, groupAndAction, v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRowsGF</code>( <var class="Arg">gens, groupAndAction, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRowsGFDestructive</code>( <var class="Arg">gens, groupAndAction, v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_CoefficientsOfGeneratingRowsGFDestructive</code>( <var class="Arg">gens, groupAndAction, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>For a single vector <var class="Arg">v</var>, it returns a vector x giving the g- coefficients from <var class="Arg">gens</var> needed to generate <var class="Arg">v</var>, i.e. the solution to the equation x*A=v, where A is the expansion of gens. If there is no solution, <code class="keyw">fail</code> is returned. If a list of vectors, <var class="Arg">coll</var>, then a vector is returned that lists the solution for each vector (any of which may be <code class="keyw">fail</code>).</p>
<p>The standard forms of this function use standard linear algebra to solve for the coefficients. The <code class="code">Destructive</code> version will corrupt both <var class="Arg">gens</var> and <var class="Arg">v</var>. The <code class="code">GF</code> versions use the block structure of the generating rows to expand only the blocks that are needed to find the solution. If the generators are in echelon form, this can save memory, but is slower.</p>
<p><a id="X83A2564481867869" name="X83A2564481867869"></a></p>
<h5>5.1-14 HAPPRIME_GenerateFromGeneratingRowsCoefficients</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GenerateFromGeneratingRowsCoefficients</code>( <var class="Arg">gens, groupAndAction, c</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GenerateFromGeneratingRowsCoefficients</code>( <var class="Arg">gens, groupAndAction, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GenerateFromGeneratingRowsCoefficientsGF</code>( <var class="Arg">gens, groupAndAction, c</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_GenerateFromGeneratingRowsCoefficientsGF</code>( <var class="Arg">gens, groupAndAction, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>Generate a vector of collection of vectors as a combination of the generators <var class="Arg">gens</var> given by the coefficients <var class="Arg">c</var>, or collection of vectors. This is simply the result of multiplying the vector <var class="Arg">c</var> or matrix <var class="Arg">coll</var> by the expansion of the generators <var class="Arg">gens</var>.</p>
<p>The standard versions of this function use standard linear algebra. The <code class="code">GF</code> versions only performs the expansion of necessary generating rows, and only expands by one group element at a time, so will only need at most twice the amount of memory as that to store <var class="Arg">gens</var>, which is a large saving over expanding the generators by every group element at the same time, as in a naive implementation. It may also be faster.</p>
<p><a id="X7830397286C3D792" name="X7830397286C3D792"></a></p>
<h5>5.1-15 HAPPRIME_RemoveZeroBlocks</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_RemoveZeroBlocks</code>( <var class="Arg">gens, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Removes from a set of generating vectors <var class="Arg">gens</var> (with group and action <var class="Arg">groupAndAction</var> any blocks that are zero in every generating vector. These will be unaffected by any row or expansion operation, and can be removed to save time or memory. The function <code class="func">HAPPRIME_AddZeroBlocks</code> (<a href="chap5.html#X795D4B5F7C443E4D"><b>5.1-16</b></a>) can be used to replace the missing zeroes. This function requires the summed block structure of <var class="Arg">gens</var>, which is returned by <code class="keyw">HAPPRIME_RemoveZeroBlocks</code>.</p>
<p><a id="X795D4B5F7C443E4D" name="X795D4B5F7C443E4D"></a></p>
<h5>5.1-16 HAPPRIME_AddZeroBlocks</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_AddZeroBlocks</code>( <var class="Arg">gens, blockStructure, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Adds zero blocks to a set of generating vectors <var class="Arg">gens</var> to make it have the block structure given in <var class="Arg">blockStructure</var> (for a given group and action <var class="Arg">groupAndAction</var>). The generators <var class="Arg">gens</var> are modified in place, and also returned.</p>
<p>The <var class="Arg">blockStructure</var> parameter is identical to that returned by a prior call to <code class="func">HAPPRIME_RemoveZeroBlocks</code> (<a href="chap5.html#X7830397286C3D792"><b>5.1-15</b></a>), which was most likely used earlier to remove zero blocks from the generators.</p>
<p><a id="X820435E87D83DF34" name="X820435E87D83DF34"></a></p>
<h4>5.2 <span class="Heading">FG-modules</span></h4>
<p>Internal helper functions for <code class="keyw">FpGModuleGFs</code>s.</p>
<p><a id="X7A5176C5844FC765" name="X7A5176C5844FC765"></a></p>
<h5>5.2-1 HAPPRIME_DirectSumForm</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_DirectSumForm</code>( <var class="Arg">current, new</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns a string containing the form of the generator matrix if the direct sum is formed between a module with the form <var class="Arg">current</var> and a module with the form <var class="Arg">new</var>. The direct sum is formed by placing the two module generating matrices in diagonal form. Given the form of the two generating matrices, this allows the form of the direct sum to be stated. See <code class="func">ModuleGeneratorsForm</code> (<a href="chap4.html#X87572B78824FB28E"><b>4.2-16</b></a>) for information about form strings.</p>
<p><a id="X873AD0187A1C3293" name="X873AD0187A1C3293"></a></p>
<h5>5.2-2 HAPPRIME_PrintModuleDescription</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_PrintModuleDescription</code>( <var class="Arg">M</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Prints the standard description of a module <var class="Arg">M</var>. This is used by <code class="keyw">PrintObj</code>, <code class="keyw">ViewObj</code> and <code class="keyw">Display</code>, with the use specified</p>
<p><a id="X870EFB907E2F5A68" name="X870EFB907E2F5A68"></a></p>
<h5>5.2-3 HAPPRIME_ModuleGeneratorCoefficients</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ModuleGeneratorCoefficients</code>( <var class="Arg">M, elm</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ModuleGeneratorCoefficientsDestructive</code>( <var class="Arg">M, elm</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ModuleGeneratorCoefficients</code>( <var class="Arg">M, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ModuleGeneratorCoefficientsDestructive</code>( <var class="Arg">M, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns the coefficients needed to make the module element <var class="Arg">elm</var> as a linear and g- combination of the module generators of the module <var class="Arg">M</var>. They coefficients are returned in standard vector form, or if there is no solution then <code class="code">fail</code> is returned. If a list of elements is given, then a list of coefficients (or <code class="code">fails</code>) is returned.</p>
<p>The <code class="code">Destructive</code> form of this function might change the elements of of <var class="Arg">M</var> or <var class="Arg">elm</var>. The non-<code class="code">Destructive</code> version makes copies to ensure that they are not changed.</p>
<table class="example">
<tr><td><pre>
</pre></td></tr></table>
<p><a id="X7B8650FA84ABBA4B" name="X7B8650FA84ABBA4B"></a></p>
<h5>5.2-4 HAPPRIME_ModuleElementFromGeneratorCoefficients</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ModuleElementFromGeneratorCoefficients</code>( <var class="Arg">M, c</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_ModuleElementFromGeneratorCoefficients</code>( <var class="Arg">M, coll</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns an element from the module <var class="Arg">M</var>, constructed as a linear and g- sum of the module generators as specified in <var class="Arg">c</var>. If a list of coefficient vectors is given, a list of corresponding module elements is returned.</p>
<table class="example">
<tr><td><pre>
</pre></td></tr></table>
<p><a id="X7EA258467C8190FB" name="X7EA258467C8190FB"></a></p>
<h5>5.2-5 HAPPRIME_MinimalGeneratorsVectorSpaceGeneratingRowsDestructive</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_MinimalGeneratorsVectorSpaceGeneratingRowsDestructive</code>( <var class="Arg">vgens, groupAndAction</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns a module with minimal generators that is equal to the FG-module with <em>vector space</em> basis <var class="Arg">vgens</var> and group and action as specified in <code class="code">groupAndAction</code> (see <code class="keyw">ModuleGroupAndAction</code>). The solution is computed by the module radical method, which is fast at the expense of memory.</p>
<p>This is a helper function for <code class="func">MinimalGeneratorsModuleRadical</code> (<a href="chap4.html#X81C340AD7EE8FA63"><b>4.2-30</b></a>) that is also used by <code class="func">ExtendResolutionPrimePowerGroupRadical</code> (<a href="chap4.html#X7B435C307F28D44F"><b>4.4-2</b></a>) (which knows that its module is already in vector-space form).</p>
<p>This function will corrupt the matrix <var class="Arg">gens</var>.</p>
<p><a id="X7ADC06E981BCF3F9" name="X7ADC06E981BCF3F9"></a></p>
<h5>5.2-6 HAPPRIME_IsGroupAndAction</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_IsGroupAndAction</code>( <var class="Arg">R</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns <code class="code">true</code> if <var class="Arg">R</var> appears to be a <code class="code">groupAndAction</code> record, or <code class="code">false</code> otherwise.</p>
<p><a id="X7C0B125E7D5415B4" name="X7C0B125E7D5415B4"></a></p>
<h4>5.3 <span class="Heading">Resolutions</span></h4>
<p>Internal helper functions for building resolutions.</p>
<p><a id="X845662157E4E0C39" name="X845662157E4E0C39"></a></p>
<h5>5.3-1 HAPPRIME_WordToVector</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_WordToVector</code>( <var class="Arg">w, dim, orderG</var> )</td><td class="tdright">( method )</td></tr></table></div>
<p>Returns the boundary map vector that corresponds to the <strong class="pkg">HAP</strong> word vector <var class="Arg">w</var> with module ambient dimension <var class="Arg">dim</var> and group order <var class="Arg">orderG</var> (assumed to be the <code class="code">actionBlockSize</code>). For example, <code class="code">[ [1,2],[2,3] ] = [ 0100|0010 ]</code>.</p>
<p><a id="X7BCD0A1D799AD760" name="X7BCD0A1D799AD760"></a></p>
<h5>5.3-2 HAPPRIME_VectorToWord</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_VectorToWord</code>( <var class="Arg">vec, orderG</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The <strong class="pkg">HAP</strong> word format vector that corresponds to the boundary vector <var class="Arg">vec</var> with <code class="code">actionBlockSize</code> assumed to be <var class="Arg">orderG</var>. For example, <code class="code">[ 0100|0010 ] = [ [1,2],[2,3] ]</code>.</p>
<p><a id="X7C79C3CE822EAE32" name="X7C79C3CE822EAE32"></a></p>
<h5>5.3-3 HAPPRIME_BoundaryMatrices</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_BoundaryMatrices</code>( <var class="Arg">R</var> )</td><td class="tdright">( method )</td></tr></table></div>
<p>If <var class="Arg">R</var> is a resolution which stores its boundaries as a list of matrices (e.g. one created by <strong class="pkg">HAPprime</strong>, this list is returned. Otherwise, <code class="code">fail</code> is returned. Note that the first matrix in this list corresponds to the zeroth degree: for resolutions of modules, this is the generators of the module; for resolutions of groups, this is the empty matrix. The second matrix corresponds to the first degree, and so on.</p>
<p><a id="X7981D36D840820BE" name="X7981D36D840820BE"></a></p>
<h5>5.3-4 HAPPRIME_AddNextResolutionBoundaryMapMatNC</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIME_AddNextResolutionBoundaryMapMatNC</code>( <var class="Arg">R, BndMat</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns the resolution <var class="Arg">R</var> extended by one term, where that term is given by the boundary map matrix <var class="Arg">BndMat</var>. If <var class="Arg">BndMat</var> is not already in compressed matrix form, it will be converted into this form, and if the boundaries in <var class="Arg">R</var> are not already in matrix form, they are all converted into this form.</p>
<p><a id="X806027CD82F501C0" name="X806027CD82F501C0"></a></p>
<h5>5.3-5 HAPPRIMECreateResolutionWithBoundaryMapMatsNC</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> HAPPRIMECreateResolutionWithBoundaryMapMatsNC</code>( <var class="Arg">R, BndMat</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns a <strong class="pkg">HAP</strong> resolution object for group <var class="Arg">G</var> where the module homomorphisms are given by the boundary matrices in the list <var class="Arg">BndMats</var>. This list is indexed with the boundary matrix for degree <em>zero</em> as the first element. If the resolution is the resolution of a module, the module's minimal generators are this first boundary matrix, otherwise (for the resolution of a group), this should be set to be the empty matrix <code class="code">[]</code>.</p>
<p><a id="X7C5563A37D566DA5" name="X7C5563A37D566DA5"></a></p>
<h4>5.4 <span class="Heading">Miscellaneous</span></h4>
<p>Miscellaneous internal helper functions.</p>
<p><a id="X825493137E595851" name="X825493137E595851"></a></p>
<h5>5.4-1 VersionWithSVN</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> VersionWithSVN</code>( <var class="Arg"></var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a string giving a current version number for the HAPprime installation assuming that it is checked out from a subversion repository. This fetches the current version number from <code class="code">PackageInfo.g</code> and appends the return of the <code class="code">svnversion</code> program to this, returning the resulting composite string.</p>
<table class="example">
<tr><td><pre>
gap> HAPPRIME_VersionWithSVN();
"0.5.168M"
</pre></td></tr></table>
<div class="chlinkprevnextbot"> <a href="chap0.html">Top of Book</a> <a href="chap4.html">Previous Chapter</a> <a href="chapInd.html">Next Chapter</a> </div>
<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chapInd.html">Ind</a> </div>
<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
5e1854624d3bc613bdd0dd13d1ef9ac7
>
files
>
1892
