GAP (IdRel) - Chapter 6: Identities Among Relators

Goto Chapter: Top 1 2 3 4 5 6 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

6 Identities Among Relators
6.1 The original approach
6.1-1 IdentitiesAmongRelators
6.1-2 RootIdentities
6.2 Knuth-Bendix identities
6.2-1 IdentitiesAmongRelatorsKB
6.3 Partial lists of elements
6.3-1 PartialElementsOfMonoidRepresentation
6.4 Identities for infinite groups

### 6 Identities Among Relators

The identities among the relators for a finitely presented group G are constructed as logged module polynomials. The procedure, described in [HW03] and based on work in [BRS99], is to construct a full set of group relator sequences for the group; convert these into module polynomials (eliminating empty sequences); and then apply simplification rules (including the primary identity property) to eliminate obvious duplicates and conjugates.

When a reduced set of polynomials has been obtained, the relator sequences from which they were formed are returned as the identities among relators for G.

Here are some of the details when working with the group S_3 = ⟨ a,b ~|~ ρ=a^3, σ=b^2, τ=(ab)^2 ⟩. The monoid presentation has generators {a^+,b^+,a^-,b^-} and relators

[~ 1 = a^+a^-,~ 2 = b^+b^-,~ 3 = a^-a^+,~ 4 = b^-b^+,~ 5 = a^{+3},~ 6 = b^{+2},~ 7 = (a^+b^+)^2 ~]\ ,

and the elements are { id, a^+,b^+,a^-,a^+b^-,b^+a^+}. The logged rewriting system has relations

a^+a^- = id,quad b^+b^- = id,quad a^-a^+ = id,quad b^-b^+ = id,
a^+2 = [5, id]a^-,quad a^-2 = [-5, id]a^+,quad b^+2 = [6, id] id,quad b^- = [-6, id]b^+,
b^+a^- = [-7,a^+b^-][6, id]a^+b^+,quad a^-b^+ = [-7,a^+][6,a^-b^-]b^+a^+,
a^+b^+a^+ = [7, id][-6, id]b^+,quad b^+a^+b^+ = [7,a^+]a^-.

To construct the identity monoid relator sequences we follow in turn the relators 5=ρ,6=σ,7=τ at each of the elements of S_3. For example, applying τ at a^+ gives the cycle:

a^+ \stackrel{a^+}{\longrightarrow} a^- \stackrel{b^+}{\longrightarrow} b^+a^+ \stackrel{a^+}{\longrightarrow} a^+b^+ \stackrel{b^+}{\longrightarrow} a^+\ .

Each of these edges has a non-trivial logged rewrite, particularly the third edge where b^+a^+a^+ -> b^+a^- -> a^+b^+. Combining this log information we obtain the sequence:

[5,{\rm id}].[-7,a^+][6,a^-b^-]. [5,{\rm id}]^{b^-}[-7,a^+b^-][6,{\rm id}].[6,{\rm id}]^{a^-}\ .

Expanding this gives:

a^+a^+a^+.a^-b^-a^-b^-a^-a^+.b^+a^+b^+b^+a^-b^-.b^+a^+a^+a^+b^-. b^+a^-b^-a^-b^-a^-a^+b^-.b^+b^+.a^+b^+b^+a^-

which cancels to leave, as expected, a^+(a^+b^+a^+b^+)a^- = [7,a^-]. Adding the inverse [-7,a^-] to the front of the log expression gives the identity

[-7,a^-].[5,{\rm id}].[-7,a^+][6,a^-b^-]. [5,b^-][-7,a^+b^-][6,{\rm id}].[6,a^-]\ .

Converting this back to the group presentation, and conjugating by a, we obtain the identity group relator sequence given in the introduction (1.1):

\tau^{-1}\; \rho^a\; \left(\tau^{-1}\right)^{a^2}\; \sigma^{a^{-1}b^{-1}a}\; \rho^{b^{-1}a}\; \left(\tau^{-1}\right)^{ab^{-1}a}\; \sigma^a\; \sigma\ .

This is then transformed into the module polynomial

\rho(a^+ + b^+a^+) + \sigma({\rm id} + a^+ + a^+b^+) - \tau({\rm id} + a^- + b^+)\ ,

where the monoid elements are transformed into their normal forms.

The collection of saturated sets of these module polynomials is then reduced as far as possible, and the minimal set obtained returned as the `IdentityYSequences` of the group. The group relator sequences corresponding to these module polynomials form the `IdentitiesAmongRelators` for the group.

#### 6.1 The original approach

This section describes the approach used from the earliest versions of IdRel up to version 2.38 in 2017. For version 2.39 the methods were revised so as to produce some data for infinite groups. This experimental work is described in later sections.

##### 6.1-1 IdentitiesAmongRelators

`‣ IdentitiesAmongRelators`( grp ) | ( attribute )

`‣ IdentityYSequences`( grp ) | ( attribute )

`‣ IdentityRelatorSequences`( grp ) | ( attribute )

It is not guaranteed that a minimal set of identities is obtained. For `q8` a set of seven identities is returned, whereas a minimal set contains only six. See Example 5.1 of [HW03] for further details.

    gap> gseq8 := IdentityRelatorSequences( q8 );;
    gap> Length( gseq8 );
    19
    gap> gseq8[1];
    [ 1, 9, [ [ q8_R1^-1, <identity ...> ], [ q8_R1, f1^-1 ] ] ]
    gap> idsq8 := IdentitiesAmongRelators( q8 );;
    gap> Length( idsq8 );
    7
    gap> Display( idsq8 );
    [ [ [ q8_R1^-1, <identity ...> ], [ q8_R1, f1^-1 ] ],
      [ [ q8_R2^-1, <identity ...> ], [ q8_R4^-1, f2^-1 ], [ q8_R2, f1^-2*f2^-1 ],
          [ q8_R4, f2^-1 ] ],
      [ [ q8_R1^-1, <identity ...> ], [ q8_R4^-1, f2^-1 ], [ q8_R3, f1^-1*f2^-1 ],
          [ q8_R3, f2^-1 ], [ q8_R3, f1*f2^-1 ], [ q8_R1^-1, f2^-1 ],
          [ q8_R3, f1^-2*f2^-1 ], [ q8_R4, f2^-1 ] ],
      [ [ q8_R3^-1, <identity ...> ], [ q8_R4^-1, f2^-1 ], [ q8_R3, f1^-1*f2^-1 ],
          [ q8_R4, f1*f2^-1 ] ],
      [ [ q8_R4^-1, <identity ...> ], [ q8_R4^-1, f2^-1 ], [ q8_R3, f1^-1*f2^-1 ],
          [ q8_R3, f2^-1 ], [ q8_R4^-1, f2^-1 ], [ q8_R2, f1^-2*f2^-1 ],
          [ q8_R4, f2^-1 ] ],
      [ [ q8_R4^-1, <identity ...> ], [ q8_R3, f1*f2 ], [ q8_R1^-1, f2 ],
          [ q8_R3, f1^-2*f2 ], [ q8_R4, f2 ] ],
      [ [ q8_R4^-1, <identity ...> ], [ q8_R4^-1, f1^-2 ], [ q8_R2, f1^-4 ],
          [ q8_R1, f1^-1 ] ] ]
    gap> idyseq8 := IdentityYSequences( q8 );
    [ ( q8_Y1*( -q8_M1), q8_R1*( q8_M1 - <identity ...>) ),
      ( q8_Y5*( <identity ...>), q8_R2*( q8_M2 - <identity ...>) ),
      ( q8_Y18*( q8_M2), q8_R1*( -q8_M2 - <identity ...>) + q8_R3*( q8_M1^2 + q8_M\
    3 + q8_M1 + <identity ...>) ),
      ( q8_Y8*( q8_M2), q8_R3*( q8_M3 - q8_M2) + q8_R4*( q8_M1 - <identity ...>) )
        ,
      ( q8_Y17*( -q8_M2), q8_R2*( -q8_M1^2) + q8_R3*( -q8_M3 - <identity ...>) + q\
    8_R4*( q8_M2 + <identity ...>) ),
      ( q8_Y11*( <identity ...>), q8_R1*( -q8_M2) + q8_R3*( q8_M1*q8_M2 + q8_M4) +\
     q8_R4*( q8_M2 - <identity ...>) ),
      ( q8_Y10*( -q8_M1), q8_R1*( -<identity ...>) + q8_R2*( -q8_M1) + q8_R4*( q8_\
    M3 + q8_M1) ) ]

##### 6.1-2 RootIdentities

`‣ RootIdentities`( grp ) | ( attribute )

The root identities are identities of the form r^wr^-1 where r = w^n is a relator and n>1. (For equivalent forms invert, or permute the factors cyclically, or act with w^-1.)

For `q8` only two of the four relators are proper powers, π=a^4 and ρ=b^4, so the root identities are π^aπ^-1 and ρ^bρ^-1. In the listing below the second of these is displayed as ρ^-1(ξ^-1)^b^-1}ρ^a^-2b^-1}ξ^b^-1}, where ξ = a^2b^2. Because the second term is the inverse of the fourth, we may convert the final three terms into a conjugate of the third, so that the identity is equivalent to ρ^-1ρ^b:

\left(\rho^{a^{-2}b^{-1}}\right)^{\xi^{b^{-1}}} ~=~ \left(\rho^{a^{-2}b^{-1}}\right)^{b(a^2b^2)b^{-1}} ~=~ \rho^b~.

    gap> RootIdentities( q8 );
    [ [ [ q8_R1^-1, <identity ...> ], [ q8_R1, f1^-1 ] ],
      [ [ q8_R2^-1, <identity ...> ], [ q8_R4^-1, f2^-1 ], [ q8_R2, f1^-2*f2^-1 ],
          [ q8_R4, f2^-1 ] ] ]
    gap> RootIdentities(s3);
    [ [ [ s3_R1^-1, <identity ...> ], [ s3_R1, f1^-1 ] ],
      [ [ s3_R2^-1, <identity ...> ], [ s3_R2, f2 ] ],
      [ [ s3_R3^-1, <identity ...> ], [ s3_R3, f1*f2 ] ] ]

#### 6.2 Knuth-Bendix identities

Given an initial set of rules, the logged Knuth-Bendix procedure considers overlaps between pairs of logged rules l_1=L_1r_1 and l_2=L_2r_2. In the case u_1l_1=l_2v_2 for some words u_1,v_2, the critical pair resulting from the overlap is (u_1r_1,r_2v_2). Logged reduction is then applied to these two words giving u_1r_1=M_1z_1 and r_2v_2=M_2z_2, say. Then, if z_1>z_2, the additional rule z_1 = (M_1^-1L_1^-u_1^-1}L_2M_2)z_2 is added. There is a similar formula when z_2>z_1.

##### 6.2-1 IdentitiesAmongRelatorsKB

`‣ IdentitiesAmongRelatorsKB`( grp ) | ( attribute )

`‣ IdentityYSequencesKB`( grp ) | ( attribute )

`‣ IdentityRelatorSequencesKB`( grp ) | ( attribute )

The third possibility is that z_1=z_2, and in this case there is no reduction rule to be added. However the log expression M_1^-1L_1^-u_1^-1}L_2M_2 must reduce to the identity, and so is an identity relator sequence. Since version 2.41 of this package, the function `LoggedRewritingSystemFpGroup` returns two lists: a complete set of reduction rules, and a set of identity relator sequences produced in this way. In the case of the quaternion group `q8` a total of 42 sequences are produced by logged Knuth-Bendix, and these are then reduced to 8 identities.

    gap> gseqKB8 := IdentityRelatorSequencesKB( q8 );;
    gap> Length(last);
    42
    gap> idrelsKB8 := IdentitiesAmongRelatorsKB( q8 );;
    gap> Display( idrelsKB8 );
    [ [ [ q8_R1^-1, <identity ...> ], [ q8_R1, f1^-1 ] ],
      [ [ q8_R3^-1, f1^-1 ], [ q8_R3^-1, f1^-2 ], [ q8_R1, <identity ...> ],
          [ q8_R3^-1, f1 ], [ q8_R1, f2^-1 ], [ q8_R3^-1, <identity ...> ] ],
      [ [ q8_R3, f1*f2 ], [ q8_R4^-1, <identity ...> ], [ q8_R3^-1, f1^-2 ],
          [ q8_R4, f1^-1 ] ],
      [ [ q8_R2^-1, f1^-3 ], [ q8_R4, f1^-1 ], [ q8_R3, <identity ...> ],
          [ q8_R3^-1, f1*f2^-1 ], [ q8_R4^-1, <identity ...> ], [ q8_R2, f1^-2 ] ]
        , [ [ q8_R4^-1, f2 ], [ q8_R2, f1^-2*f2 ], [ q8_R4^-1, <identity ...> ],
          [ q8_R3, f1^-1 ], [ q8_R3, <identity ...> ] ],
      [ [ q8_R4^-1, <identity ...> ], [ q8_R3^-1, f1^-2 ],
          [ q8_R1, <identity ...> ], [ q8_R3^-1, f1 ], [ q8_R4, f2^-1 ] ],
      [ [ q8_R4^-1, <identity ...> ], [ q8_R4^-1, f1^-2 ], [ q8_R2, f1^-4 ],
          [ q8_R1, <identity ...> ] ],
      [ [ q8_R4, f1^-1 ], [ q8_R3, f1*f2 ], [ q8_R1^-1, f2 ],
          [ q8_R2^-1, f1^-2*f2 ], [ q8_R4, f2 ], [ q8_R3, f1 ], [ q8_R3^-1, f2 ],
          [ q8_R4^-1, <identity ...> ], [ q8_R3, f1^-1 ], [ q8_R4^-1, f1^-1 ],
          [ q8_R2, f1^-3 ] ] ]

#### 6.3 Partial lists of elements

As we have seen, the procedure for obtaining identities involves applying each relator at each element of the group. Since this will not terminate when the group is infinite, we include an operation to construct words up to a given length in the monoid representation of the group.

##### 6.3-1 PartialElementsOfMonoidRepresentation

`‣ PartialElementsOfMonoidRepresentation`( G, len ) | ( operation )

As an example we take the group ⟨ u,v,w ~|~ u^3, v^2, w^2, (uv)^2, (vw)^2⟩.

    gap> F := FreeGroup(3);;
    gap> u := F.1;;  v := F.2;;  w := F.3;;
    gap> rels := [ u^3, v^2, w^2, (u*v)^2, (v*w)^2 ];;
    gap> q0 := F/rels;;
    gap> SetArrangementOfMonoidGenerators( q0, [1,-1,2,-2,3,-3] );
    gap> SetName( q0, "q0" );
    gap> monq0 := MonoidPresentationFpGroup( q0 );
    monoid presentation with group relators
    [ q0_M1^3, q0_M3^2, q0_M5^2, (q0_M1*q0_M3)^2, (q0_M3*q0_M5)^2 ]
    gap> lrws := LoggedRewritingSystemFpGroup( q0 );;
    gap> PartialElementsOfMonoidPresentation( q0, 1 );
    [ <identity ...>, q0_M1, q0_M2, q0_M3, q0_M5 ]
    gap> PartialElementsOfMonoidPresentation( q0, 2 );
    [ <identity ...>, q0_M1, q0_M2, q0_M3, q0_M5, q0_M1*q0_M3, q0_M1*q0_M5,
      q0_M2*q0_M3, q0_M2*q0_M5, q0_M3*q0_M5, q0_M5*q0_M1, q0_M5*q0_M2 ]

#### 6.4 Identities for infinite groups

Because the list of elements is incomplete, it is not guaranteed that the list of identities is complete.

    gap> idsq0 := IdentitiesAmongRelators( q0 );
    [ [ [ q0_R1^-1, <identity ...> ], [ q0_R1, f1^-1 ] ],
      [ [ q0_R2^-1, <identity ...> ], [ q0_R2, f2 ] ],
      [ [ q0_R3^-1, <identity ...> ], [ q0_R3, f3 ] ],
      [ [ q0_R4^-1, <identity ...> ], [ q0_R2^-1, f1^-1 ], [ q0_R4, f1*f2 ],
          [ q0_R2, f1*f2 ] ],
      [ [ q0_R5^-1, <identity ...> ], [ q0_R3^-1, f2^-1 ], [ q0_R5, f2*f3 ],
          [ q0_R3, f2*f3 ] ],
      [ [ q0_R1^-1, <identity ...> ], [ q0_R2^-1, f1^-1 ], [ q0_R4, f1*f2 ],
          [ q0_R2^-1, f1^-1*f2^-1*f1*f2 ], [ q0_R4, f1^2*f2 ], [ q0_R1^-1, f2 ],
          [ q0_R2^-1, f1^-1*f2^-1*f1^-1*f2 ], [ q0_R4, f2 ] ],
      [ [ q0_R2^-1, <identity ...> ], [ q0_R3^-1, f2^-1 ], [ q0_R5, f2*f3 ],
          [ q0_R2^-1, f3 ], [ q0_R3^-1, f2^-1*f3^-1*f2^-1*f3 ], [ q0_R5, f3 ] ] ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 Bib Ind

generated by GAPDoc2HTML