Goto Chapter: Top 1 2 3 4 5 Bib Ind
Top of Book Previous Chapter Next Chapter

4. Monoid Polynomials
4.1 Construction of monoid polynomials
4.1-1 MonoidPolyFromCoeffsWords
4.2 Components of a polynomial
4.2-1 Terms
4.2-2 Monic
4.2-3 AddTermMonoidPoly
4.3 Monoid Polynomial Operations
4.3-1 Length
4.4 Reduction of a Monoid Polynomial
4.4-1 ReduceMonoidPoly

### 4. Monoid Polynomials

This chapter describes functions to compute with elements of a free noncommutative algebra. The elements of the algebra are sums of rational multiples of words in a free monoid. These will be called monoid polynomials, and are stored as lists of pairs `[coefficient, word]`.

#### 4.1 Construction of monoid polynomials

##### 4.1-1 MonoidPolyFromCoeffsWords

`> MonoidPolyFromCoeffsWords`( coeffs, words ) | ( operation )

`> MonoidPoly`( terms ) | ( operation )

`> ZeroMonoidPoly`( F ) | ( operation )

There are two possible ways to input a monoid polynomial. The first is by listing the coefficients and then the words; the second is by listing the terms as a list of pairs `[coefficient, word]`. Note that if a word occurs more than once in the input list, the coefficients will be added so that the terms of the monoid polynomial recorded do not contain any duplicates. The zero monoid polynomial is the polynomial with no terms.

    gap> rels := RelatorsOfFpGroup( q8 );
    [ f1^4, f2^4, f1*f2*f1*f2^-1, f1^2*f2^2 ]
    gap> freeq8 := FreeGroupOfFpGroup( q8 );
    Group( [f1, f2] )
    gap> gens := GeneratorsOfGroup( freeq8 );;
    gap> famfree := ElementsFamily( FamilyObj( freeq8 ) );
    NewFamily( "FreeGroupElementsFamily", [ 125, 144, 989 ],
    [ 76, 77, 78, 79, 111, 114, 117, 121, 125, 144, 989 ] )
    gap> famfree!.monoidPolyFam := MonoidPolyFam;
    NewFamily( "MonoidPolyFam", [ 2416 ], [ 111, 114, 117, 2416 ] )
    gap> cg := [6,7];
    [ 6, 7 ]
    gap> cr := [3,4,-5,-2];
    [ 3, 4, -5, -2 ]
    gap> pg := MonoidPolyFromCoeffsWords( cg, gens );
    <monpoly>
    gap> Print( pg );
    7*f2 + 6*f1
    gap> pr := MonoidPolyFromCoeffsWords( cr, rels );
    <monpoly>
    gap> Print( pr );
    4*f2^4 - 5*f1*f2*f1*f2^-1 - 2*f1^2*f2^2 + 3*f1^4
    gap> zeromp := ZeroMonoidPoly( freeq8 );
    <monpoly>
    gap> Print( zeromp);
    zero monpoly

#### 4.2 Components of a polynomial

##### 4.2-1 Terms

`> Terms`( poly ) | ( attribute )

`> Coeffs`( poly ) | ( attribute )

`> Words`( poly ) | ( attribute )

`> LeadTerm`( poly ) | ( attribute )

`> LeadCoeffMonoidPoly`( poly ) | ( attribute )

The function `Terms` returns the terms of a polynomial as a list of pairs of the form `[word, coefficient]`. The function `Coeffs` returns the coefficients of a polynomial as a list, and the function `Words` returns the words of a polynomial as a list. The function `LeadTerm` returns the term of the polynomial whose word component is the largest with respect to the length-lexicographical ordering. The function `LeadCoeffMonoidPoly` returns the coefficient of the leading term of a polynomial.

    gap> Coeffs( pr );
    [ 4, -5, -2, 3 ]
    gap> Terms( pr );
    [ [ 4, f2^4 ], [ -5, f1*f2*f1*f2^-1 ], [ -2, f1^2*f2^2 ], [ 3, f1^4 ] ]
    gap> Words( pr );
    [ f2^4, f1*f2*f1*f2^-1, f1^2*f2^2, f1^4 ]
    gap> LeadTerm( pr );
    [ 4, f2^4]
    gap> LeadCoeffMonoidPoly( pr );
    4

##### 4.2-2 Monic

`> Monic`( poly ) | ( operation )

A monoid polynomial is called monic if the coefficient of its leading polynomial is one. The function `Monic` converts a polynomial into a monic polynomial by dividing all the coefficients by the leading coefficient.

    gap> mpr := Monic( pr );;
    gap> Print( mpr );
    f2^4 - 5/4*f1*f2*f1*f2^-1 - 1/2*f1^2*f2^2 + 3/4*f1^4

##### 4.2-3 AddTermMonoidPoly

`> AddTermMonoidPoly`( poly, coeff, word ) | ( operation )

The function `AddTermMonoidPoly` adds a new term, given by its coeffiecient and word, to an existing polynomial.

    gap> w := gens[1]^gens[2];
    f2^-1*f1*f2
    gap> cw := 3/4;;
    gap> wpg:= AddTermMonoidPoly( pg, cw, w);
    <monpoly>
    gap> Print( wpg );
    3/4*f2^-1*f1*f2 + 7*f2 + 6*f1

#### 4.3 Monoid Polynomial Operations

Tests for equality and arithmetic operations are performed in the usual way.

The operation `poly1 = poly2` returns `true` if the monoid polynomials have the same terms, and `false` otherwise. Multiplication of a monoid polynomial (on the left or right) by a coefficient; the addition or subtraction of two monoid polynomials; multiplication (on the right) of a monoid polynomial by a word; and multiplication of two monoid polynomials; are all implemented.

    gap> pg = pg;
    true
    gap> pg = pr;
    false
    gap> prcw := pr*cw;
    3*f2^4 - 15/4*f1*f2*f1*f2^-1 - 3/2*f1^2*f2^2 + 9/4*f1^4
    gap> cwpr := cw*pr;
    3*f2^4 - 15/4*f1*f2*f1*f2^-1 - 3/2*f1^2*f2^2 + 9/4*f1^4
    gap> pr = prcw;
    false
    gap> prcw = cwpr;
    true
    gap> Print( pg + pr );
    4*f2^4 - 5*f1*f2*f1*f2^-1 - 2*f1^2*f2^2 + 3*f1^4 + 7*f2 + 6*f1
    gap> Print( pg - pr );
    - 4*f2^4 + 5*f1*f2*f1*f2^-1 + 2*f1^2*f2^2 - 3*f1^4 + 7*f2 + 6*f1
    gap> Print( pg * w );
    6*f1*f2^-1*f1*f2 + 7*f1*f2
    gap> Print( pg * pr );
    28*f2^5 - 35*f2*f1*f2*f1*f2^-1 - 14*f2*f1^2*f2^2 + 21*f2*f1^4
    + 24*f1*f2^4 - 30*f1^2*f2*f1*f2^-1 - 12*f1^3*f2^2 + 18*f1^5

##### 4.3-1 Length

`> Length`( poly ) | ( attribute )

This function returns the number of distinct terms in the monoid polynomial.

    gap> Length( pr );
    4

The boolean function `poly1 > poly2` returns `true` if the first polynomial has more terms than the second. If the polynomials are the same length it will compare their leading terms. If the leading word of the first is lengthlexicographically greater than the leading word of the second, or if the words are equal but the coefficient of the first is greater than the coefficient of the second then true is returned. If the leading terms are equal then the next terms are compared in the same way. If all terms are the same then `false` is returned.

    gap> pol > 3*pol;
    false
    gap> pol > redpol;
    true

#### 4.4 Reduction of a Monoid Polynomial

##### 4.4-1 ReduceMonoidPoly

`> ReduceMonoidPoly`( poly, rules ) | ( operation )

Recall that the words of a monoid polynomial are elements of a free monoid. Given a rewrite system (set of rules) on the free monoid the words can be reduced. This allows us to simulate calculation in monoid rings where the monid is given by a complete presentation. This function reduces the words of the polynomial (elements of the free monoid) with respect to the complete rewrite system. The words of the reduced polynomial are normal forms for the elements of the monoid presented by that rewite system.

    gap> M := genfgmon;
    [ q8_Ml, q8_M2, q8_M3, q8_M4 ]
    gap> r2;
    [ q8_Ml*q8_M3, <identity ...>], [ q8_M2*q8_Ml, q8_Ml*q8_M4 ],
      [ q8_M2^2, q8_Ml^2], [ q8_M2*q8_M3, q8_Ml*q8_M2 ],
      [ q8_M2*q8_M4, <identity ...> ], [ q8_M3*q8_Ml, <identity ...> ],
      [ q8_M3*q8_M2, q8_Ml*q8_M4], [ q8_M3^2, q8_Ml^2 ],
      [ q8_M3*q8_M4, q8_Ml*q8_M2], [ q8_M4*q8_Ml, q8_Ml*q8_M2 ],
      [ q8_M4*q8_M2, <identity ...> ], [ q8_M4*q8_M3, q8_Ml*q8_M4 ],
      [ q8_M4^2, q8_Ml^2 ], [ q8_Ml^3, q8_M3], [ q8_Ml^2*q8_M2, q8_M4 ],
      [ q8_Ml^2*q8_M4, q8_M2 ] ]
    gap> pol := MonoidPolyFromCoeffsWords([3,2,-5], [M[1]*M[3] ,M[2]-4,M[1]]);
    <monpoly>
    gap> Print( pol );
    2*q8_M2^4 + 3*q8_Ml*q8_M3 - 5*q8_Ml
    gap> redpol := ReduceMonoidPoly( pol, KBrules );
    <monpoly>
    gap> Print( redpol );
    - 5*q8_Ml + 5*<identity ...>

Top of Book Previous Chapter Next Chapter
Goto Chapter: Top 1 2 3 4 5 Bib Ind

generated by GAPDoc2HTML