In this chapter we consider finitely generated modules over the
monoid rings considered previously.
We call an element of this module a <E>module polynomial</E>,
and we describe functions to construct module polynomials
and the standard algebraic operations for such polynomials.
<P/>
A module polynomial <C>modpoly</C> is recorded as a list of pairs,
<C>[ gen, monpoly ]</C>,
where <C>gen</C> is a module generator (basis element),
and <C>monpoly</C> is a monoid polynomial.
The module polynomial is printed as the formal sum
of monoid polynomial multiples of the generators.
Note that the monoid polynomials are the coefficients
of the module polynomials and appear to the right of the generator,
as we choose to work with right modules.
<P/>
The examples we are aiming for are the identities among the relators
of a finitely presented group (see section <B>5.4</B>).
<Section><Heading>Construction of module polynomials</Heading>
<ManSection>
<Oper Name="ModulePoly"
Arg="gens, monpolys" Label="with input gens, polys" />
<Oper Name="ModulePoly"
Arg="args" Label="with input [gen,poly] list" />
<Oper Name="ZeroModulePoly"
Arg="Fgens, Fmon" />
<Description>
The function <C>ModulePoly</C> returns a module polynomial.
The terms of the polynomial may be input as a list of generators
followed by a list of monoid polynomials or as one list of
<C>[generator, monoid polynomial]</C> pairs.
<P/>
Assuming that <C>Fgens</C> is the free group on the module generators
and <C>Fmon</C> is the free group on the monoid generators,
the function <C>ZeroModulePoly</C> returns the zero module polynomial,
which has no terms, and is an element of the module.
<P/>
</Description>
</ManSection>
<Example>
<![CDATA[
gap> q8R := FreeRelatorGroup( q8 );;
gap> genq8R := GeneratorsOfGroup( q8R );
[ q8_R1, q8_R2, q8_R3, q8_R4 ]
gap> q8Rlabs := [ "q", "r", "s", "t" ];;
gap> Print( rmp1, "\n" );
- 7*q8_M4 + 5*q8_M1 + 9*<identity ...>
gap> M := GeneratorsOfGroup( fmq8 );
[ q8_M1, q8_M2, q8_M3, q8_M4 ]
gap> mp2 := MonoidPolyFromCoeffsWords( [4,-5], [ M[4], M[1] ] );;
gap> Print( mp2, "\n" );
4*q8_M4 - 5*q8_M1
gap> zeromp := ZeroModulePoly( q8R, freeq8 );
zero modpoly
gap> s1 := ModulePoly( [ genq8R[4], genq8R[1] ], [ rmp1, mp2 ] );
q8_R1*(4*q8_M4 - 5*q8_M1) + q8_R4*( - 7*q8_M4 + 5*q8_M1 + 9*<identity ...>)
]]>
</Example>
<ManSection>
<Oper Name="PrintLnModulePoly"
Arg="obj, gens1, labs1, gens2, labs2"
Label="input object, [gens,labels] for the group, ditto relators" />
<Oper Name="PrintModulePoly"
Arg="obj, gens1, labs1, gens2, labs2"
Label="input object, [gens,labels] for the group, ditto relators" />
<Description>
The function <C>PrintModulePoly</C> prints a module polynomial,
using the function <C>PrintUsingLabels</C>.
Two lists of labels are involved: those for the fp-group being investigated,
and those for the free relator group of this group.
The function <C>PrintLnModulePoly</C> does exactly the same,
and then appends a newline.
<P/>
</Description>
</ManSection>
<Example>
<![CDATA[
gap> q8Rlabs := [ "q", "r", "s", "t" ];;
gap> PrintLnModulePoly( s1, genfgmon, q8labs, genq8R, q8Rlabs );
q*(4*B + -5*a) + t*(-7*B + 5*a + 9*id)
gap> s2 := ModulePoly( [ genq8R[3], genq8R[2], genq8R[1] ],
> [ -1*rmp1, 3*mp2, (rmp1+mp2) ] );;
gap> PrintLnModulePoly( s2, genfgmon, q8labs, genq8R, q8Rlabs );
q*(-3*B + 9*id) + r*(12*B + -15*a) + s*(7*B + -5*a + -9*id)
]]>
</Example>
</Section>
<Section><Heading>Components of a module polynomial</Heading>
<ManSection>
<Attr Name="Terms"
Arg="modpoly" Label="for module polynomials" />
<Attr Name="LeadTerm"
Arg="modpoly" Label="for module polynomials" />
<Attr Name="LeadMonoidPoly"
Arg="modpoly" />
<Meth Name="Length"
Arg="modpoly" Label="for module polynomials" />
<Attr Name="One"
Arg="modpoly" />
<Description>
The function <C>Terms</C> returns the terms of a module polynomial
as a list of pairs.
In <C>LeadTerm</C>, the generators are ordered,
and the term of <C>modpoly</C> with the highest value generator
is defined to be the leading term.
The monoid polynomial (coefficient) part of the leading term
is returned by the function <C>LeadMonoidPoly</C>.
<P/>
The function <C>Length</C> counts the number of module generators
which occur in <C>modpoly</C>
(a generator occurs in a polynomial if it has nonzero coefficient).
The function <C>One</C> returns the identity in
the free group on the generators.
<P/>
</Description>
</ManSection>
<Example>
<![CDATA[
gap> [ Length(s1), Length(s2) ];
[ 2, 3 ]
gap> One( s1 );
<identity ...>
gap> terms := Terms( s1 );;
gap> for t in terms do
> PrintModulePolyTerm( t, genfmq8, q8labs, genq8R, q8Rlabs );
> Print( "\n" );
> od;
q*(4*B + -5*a)
t*(-7*B + 5*a + 9*id)
gap> t1 := LeadTerm( s1 );;
gap> PrintModulePolyTerm( t1, genfmq8, q8labs, genq8R, q8Rlabs );
t*(-7*B + 5*a + 9*id)
gap> t2 := LeadTerm( s2 );;
gap> PrintModulePolyTerm( t2, genfmq8, q8labs, genq8R, q8Rlabs );
s*(7*B + -5*a + -9*id)
gap> p1 := LeadMonoidPoly( s1 );
- 7*q8_M4 + 5*q8_M1 + 9*<identity ...>
gap> p2 := LeadMonoidPoly( s2 );
7*q8_M4 - 5*q8_M1 - 9*<identity ...>
]]>
</Example>
</Section>
<ManSection>
<Oper Name="AddTermModulePoly"
Arg="modpoly, gen, monpoly" />
<Description>
The function <C>AddTermModulePoly</C> adds a term <C>[gen, monpoly]</C>
to a module polynomial <C>modpoly</C>.
<P/>
Tests for equality and arithmetic operations are performed in the usual way.
Module polynomials may be added or subtracted.
A module polynomial can also be multiplied on the right by a word
or by a scalar.
The effect of this is to multiply the monoid polynomial parts of each term
by the word or scalar.
This is made clearer in the example.
<P/>
</Description>
</ManSection>
<Example>
<![CDATA[
gap> mp0 := MonoidPolyFromCoeffsWords( [6], [ M[2] ] );;
gap> s0 := AddTermModulePoly( s1, genq8R[3], mp0 );
q8_R1*(4*q8_M4 - 5*q8_M1) + q8_R3*(6*q8_M2) + q8_R4*( - 7*q8_M4 + 5*q8_M1 +
9*<identity ...>)
gap> Print( s1 + s2, "\n" );
q8_R1*( q8_M4 - 5*q8_M1 + 9*<identity ...>) + q8_R2*(12*q8_M4 -
15*q8_M1) + q8_R3*(7*q8_M4 - 5*q8_M1 - 9*<identity ...>) + q8_R4*( -
7*q8_M4 + 5*q8_M1 + 9*<identity ...>)
gap> Print( s1 - s0, "\n" );
q8_R3*( - 6*q8_M2)
gap> Print( s1 * 1/2, "\n" );
q8_R1*(2*q8_M4 - 5/2*q8_M1) + q8_R4*( - 7/2*q8_M4 + 5/2*q8_M1 + 9/
2*<identity ...>)
gap> Print( s1 * M[1], "\n" );
q8_R1*(4*q8_M4*q8_M1 - 5*q8_M1^2) + q8_R4*( - 7*q8_M4*q8_M1 + 5*q8_M1^2 +
9*q8_M1)
]]>
</Example>
</Section>
</Chapter>
¤ Dauer der Verarbeitung: 0.26 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
