GAP (lpres) - Chapter 2: An Introduction to L-presented groups

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

[MathJax off]

2 An Introduction to L-presented groups
2.1 Definitions
2.2 Creating an L-presented group
2.2-1 LPresentedGroup
2.2-2 ExamplesOfLPresentations
2.2-3 FreeEngelGroup
2.2-4 FreeBurnsideGroup
2.2-5 FreeNilpotentGroup
2.2-6 GeneralizedFabrykowskiGuptaLpGroup
2.2-7 LamplighterGroup
2.2-8 EmbeddingOfIASubgroup
2.3 The underlying free group
2.3-1 FreeGroupOfLpGroup
2.3-2 FreeGeneratorsOfLpGroup
2.3-3 GeneratorsOfGroup
2.3-4 UnderlyingElement
2.3-5 ElementOfLpGroup
2.4 Accessing an L-presentation
2.4-1 FixedRelatorsOfLpGroup
2.4-2 IteratedRelatorsOfLpGroup
2.4-3 EndomorphismsOfLpGroup
2.5 Attributes and properties of L-presented groups
2.5-1 UnderlyingAscendingLPresentation
2.5-2 UnderlyingInvariantLPresentation
2.5-3 IsAscendingLPresentation
2.5-4 IsInvariantLPresentation
2.5-5 EmbeddingOfAscendingSubgroup
2.6 Methods for L-presented groups
2.6-1 EpimorphismFromFpGroup
2.6-2 SplitExtensionByAutomorphismsLpGroup
2.6-3 AsLpGroup
2.6-4 IsomorphismLpGroup

### 2 An Introduction to L-presented groups

#### 2.1 Definitions

Let \(S\) be an alphabet, \(Q\) and \(R\) be subsets of the free group \(F_S\) over this alphabet, and \(\Phi\) be a set of free group endomorphisms \(\varphi\colon F_S\to F_S\). An L-presentation is a quadruple \((S,Q,\Phi,R)\) and it is called finite if the sets \(S\), \(Q\), \(\Phi\), and \(R\) are finite. A (finite) L-presentation \((S,Q,\Phi,R)\) defines the (finitely) L-presented group

\[ G=\left\langle S \left| Q\cup \bigcup_{\varphi\in\Phi^*}R^\varphi\right.\right\rangle\]

where \(\Phi^*\) denotes the free monoid generated by \(\Phi\); that is, the closure of \(\Phi\cup\{\rm id\}\) under composition.

The elements in \(Q\) are the fixed relators and the elements in \(R\) are the iterated relators of the L-presentation \((S,Q,\Phi,R)\). An L-presentation of the form \((S,\emptyset,\Phi,R)\) is an ascending L-presentation and it is an invariant L-presentation if the normal subgroup

\[K=\left\langle Q\cup \bigcup_{\varphi\in\Phi^*}R^\varphi\right\rangle^{F_S}\]

is \(\varphi\)-invariant for each \(\varphi\in\Phi\); that is, if \(K\) satisfies \(K^\varphi\subset K\) for each \(\varphi\in\Phi\). Note that every ascending L-presentation is invariant and for each L-presentation \((S,Q,\Phi,R)\) there is a unique underlying ascending L-presentation \((S,\emptyset,\Phi,R)\) which is invariant. In general it is not decidable whether or not a given L-presentation is invariant as this would require a solution to the word-problem.

In the remainder of this manual, an L-presented group is always finitely L-presented.

#### 2.2 Creating an L-presented group

The construction of an L-presented group is similar to the construction of a finitely presented group (see Chapter Reference: Finitely Presented Groups of the GAP Reference manual for further details).

##### 2.2-1 LPresentedGroup

`‣ LPresentedGroup`( F, frels, endos, irels ) | ( function )

returns the GAP object of an L-presented group with the underlying free group F, the fixed relators frels, the set of endomorphisms endos, and the iterated relators irels. The input variables frels and irels need to be finite subsets of the underlying free group F and endos needs to be a finite list of homomorphisms \(F\to F\).

For example, the Grigorchuk group,

\[ \Big\langle a,b,c,d \Big| a^2,b^2,c^2,d^2,bcd,[d,d^a]^{\sigma^n},[d,d^{acaca}]^{\sigma^n},(n\inℕ_0) \Big\rangle,\]

can be constructed as follows.

    gap> F:=FreeGroup( "a", "b", "c", "d" );
    <free group on the generators [ a, b, c, d ]>
    gap> AssignGeneratorVariables( F );
    #I  Assigned the global variables [ a, b, c, d ]
    gap> frels:=[a^2, b^2, c^2, d^2, b*c*d];;
    gap> endos:=[GroupHomomorphismByImagesNC( F, F, [a, b, c, d], [c^a, d, b, c])];;
    gap> irels:=[Comm( d, d^a ), Comm( d, d^(a*c*a*c*a) )];;
    gap> G:=LPresentedGroup( F, frels, endos, irels );
    <L-presented group on the generators [ a, b, c, d ]>

There are various examples of finitely L-presented groups available in the library of the lpres-package.

##### 2.2-2 ExamplesOfLPresentations

`‣ ExamplesOfLPresentations`( n ) | ( function )

returns some well-known examples of finitely L-presented groups. The input of this function needs to be a positive integer at most \(10\).

n=1

  The Grigorchuk group on 4 generators; cf. [Gri80], [Lys85], and [Bar03, Theorem 4.6],

n=2

  the Grigorchuk group on 3 generators; cf. [Gri80], [Lys85], and [Bar03, Theorem 4.6],

n=3

  the lamplighter group \(ℤ/2\wrℤ\); cf. [Bar03, Theorem 4.1],

n=4

  the Brunner-Sidki-Vieira group; cf. [BSV99] and [Bar03, Theorem 4.4],

n=5

  the Grigorchuk supergroup; cf. [BG02] and [Bar03, Theorem 4.6],

n=6

  the Fabrykowski-Gupta group; cf. [FG85] and [BEH08],

n=7

  the Gupta-Sidki group; cf. [Sid87] and [BEH08],

n=8

  an index-\(3\) subgroup of the Gupta-Sidki group,

n=9

  the Basilica group; cf. [GtZ02] and [BV05],

n=10

  Baumslag's finitely generated, infinitely related group with a trivial multiplier; cf. [Bau71].

Furthermore, every free group in a variety of groups satisfying finitely many identities is finitely L-presented. Some of these groups are available from the lpres-package using the following operations; for further details we refer to the diploma thesis [Har08].

##### 2.2-3 FreeEngelGroup

`‣ FreeEngelGroup`( n, num ) | ( operation )

returns an L-presentation for the free n-Engel group on num generators; that is, the free group in the variety of num-generated groups satisfying the n-Engel identity.

##### 2.2-4 FreeBurnsideGroup

`‣ FreeBurnsideGroup`( exp, num ) | ( operation )

returns an L-presentation for the free Burnside group on num generators with exponent exp; that is, the free group in the variety of num-generated groups with exponent exp.

##### 2.2-5 FreeNilpotentGroup

`‣ FreeNilpotentGroup`( c, num ) | ( operation )

returns an L-presentation for the free nilpotent group of class c on num generators; that is, the free group in the variety of num-generated, nilpotent groups with nilpotency class c.

##### 2.2-6 GeneralizedFabrykowskiGuptaLpGroup

`‣ GeneralizedFabrykowskiGuptaLpGroup`( n ) | ( operation )

returns an L-presentation for the n-th generalized Fabrykowski-Gupta group as constructed in [BEH08].

##### 2.2-7 LamplighterGroup

`‣ LamplighterGroup`( filter, int ) | ( operation )

`‣ LamplighterGroup`( filter, pcgroup ) | ( operation )

returns a finite L-presentation for the lamplighter group on int lamp states in the first case, if filter is the filter `IsLpGroup`. In the second case, the group pcgroup must be a finite cyclic group. Then the method returns a finite L-presentation for the lamplighter group on `Size(pcgroup)` lamp states; for details on the L-presentation see [Bar03].

    gap> LamplighterGroup( IsLpGroup, 2 );
    <L-presented group on the generators [ a, t, u ]>
    gap> LamplighterGroup( IsLpGroup, CyclicGroup(3) );
    <L-presented group on the generators [ a, t, u ]>

##### 2.2-8 EmbeddingOfIASubgroup

`‣ EmbeddingOfIASubgroup`( a ) | ( operation )

computes an L-presentation for the IA-automorphism group of a free group. This is the subgroup of automorphisms of a free group \(f\) that act trivially on the abelianization of \(f\).

The L-presentation is taken from [DP].

    gap> f := FreeGroup(3);
    <free group on the generators [ f1, f2, f3 ]>
    gap> a := AutomorphismGroup(f);
    <group of size infinity with 3 generators>
    gap> ia := Source(EmbeddingOfIASubgroup(a));
    <invariant LpGroup on the generators [ C(1,2), C(1,3), C(2,1), C(2,3), C(3,1), C(3,2), M(1,[2,3]),
      M(2,[1,3]), M(3,[1,2]) ]>
    gap> rank := 3;
    3
    gap> q := NilpotentQuotient(ia,rank);;
    gap> lcs := LowerCentralSeries(q);;
    gap> for i in [1..Length(lcs)-1] do
    >         r := AbelianInvariants(lcs[i]/lcs[i+1]);
    >         Print(i); if i>3 then Print("th"); else Print(ELM_LIST(["st","nd","rd"],i)); fi;
    >         Print(" quotient: abelian invariants ",r," (collected ",Collected(r),")\n");
    >     od;
    1st quotient: abelian invariants [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ] (collected [ [ 0, 9 ] ])
    2nd quotient: abelian invariants [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
     ] (collected [ [ 0, 18 ] ])
    3rd quotient: abelian invariants [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
      2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3 ] (collected [ [ 0, 43 ], [ 2, 14 ], [ 3, 9 ] ])

#### 2.3 The underlying free group

An L-presented group is defined as an image of its underlying free group. Note that these are two different GAP objects. The elements of the L-presented group are represented by words in the underlying free group.

##### 2.3-1 FreeGroupOfLpGroup

`‣ FreeGroupOfLpGroup`( lpgroup ) | ( attribute )

Returns: the underlying free group of the L-presented group lpgroup

##### 2.3-2 FreeGeneratorsOfLpGroup

`‣ FreeGeneratorsOfLpGroup`( lpgroup ) | ( attribute )

Returns: the generators of the free group which underlies the L-presented group lpgroup

##### 2.3-3 GeneratorsOfGroup

`‣ GeneratorsOfGroup`( lpgroup ) | ( attribute )

Returns: the generators of the L-presented group lpgroup. These are the images of the generators of the underlying free group under the natural homomorphism.

##### 2.3-4 UnderlyingElement

`‣ UnderlyingElement`( elm ) | ( operation )

returns the preimage of an L-presented group element elm in the underlying free group. More precisely, each element of an L-presented group is represented by an element in the free group. This method returns the corresponding element in the free group.

##### 2.3-5 ElementOfLpGroup

`‣ ElementOfLpGroup`( fam, elm ) | ( operation )

returns the element in the L-presented group represented by the word elm on the generators of the underlying free group, if fam is the family of L-presented group elements.

    gap> F:=FreeGroup( 2 );;
    gap> G:=LPresentedGroup( F, [ F.1^2 ], [ IdentityMapping( F ) ], [ F.2 ] );;
    gap> FreeGroupOfLpGroup( G ) = F;
    true
    gap> GeneratorsOfGroup( G );
    [ f1, f2 ]
    gap> FreeGeneratorsOfLpGroup( G );
    [ f1, f2 ]
    gap> last = last2;
    false
    gap> UnderlyingElement( G.1 );
    f1
    gap> last in F;
    true
    gap> ElementOfLpGroup( ElementsFamily( FamilyObj( G ) ), last2 ) in G;
    true

#### 2.4 Accessing an L-presentation

The fixed relators, the iterated relators, and the endomorphisms of an L-presented group are accessible with the following methods.

##### 2.4-1 FixedRelatorsOfLpGroup

`‣ FixedRelatorsOfLpGroup`( lpgroup ) | ( attribute )

Returns: the fixed relators of the L-presented group lpgroup as elements of the underlying free group.

##### 2.4-2 IteratedRelatorsOfLpGroup

`‣ IteratedRelatorsOfLpGroup`( lpgroup ) | ( attribute )

Returns: the iterated relators of the L-presented group lpgroup as elements of the underlying free group.

##### 2.4-3 EndomorphismsOfLpGroup

`‣ EndomorphismsOfLpGroup`( lpgroup ) | ( attribute )

Returns: the endomorphisms of the L-presented group lpgroup as endomorphisms of the underlying free group.

    gap> F:=FreeGroup( 2 );;
    gap> G:=LPresentedGroup( F, [ F.1^2 ], [ IdentityMapping( F ) ], [ F.2 ] );
    <L-presented group on the generators [ f1, f2 ]>
    gap> FixedRelatorsOfLpGroup( G );
    [ f1^2 ]
    gap> IteratedRelatorsOfLpGroup( G );
    [ f2 ]
    gap> EndomorphismsOfLpGroup( G );
    [ IdentityMapping( <free group on the generators [ f1, f2 ]> ) ]

#### 2.5 Attributes and properties of L-presented groups

For the method-selection of the nilpotent quotient algorithm, an L-presented group may have the following attributes and properties.

##### 2.5-1 UnderlyingAscendingLPresentation

`‣ UnderlyingAscendingLPresentation`( lpgroup ) | ( attribute )

returns the underlying ascending L-presentation of lpgroup; that is, if lpgroup is finitely L-presented by \((S,Q,\Phi,R)\), the underlying ascending L-presentation is \((S,\emptyset,\Phi,R)\).

##### 2.5-2 UnderlyingInvariantLPresentation

`‣ UnderlyingInvariantLPresentation`( lpgroup ) | ( attribute )

attempts to compute a ``good'' underlying invariant L-presentation for lpgroup; that is, if lpgroup is finitely L-presented by \((S,Q,\Phi,R)\), then this method seeks to find a subset \(Q'\subseteq Q\) such that \((S,Q',\Phi,R)\) is an invariant L-presentation. Note that there is always the underlying ascending L-presentation \((S,\emptyset,\Phi,R)\). However, for the efficiency of the nilpotent quotient algorithm it is important that the subset \(Q'\) is as big as possible.

Since it is undecidable, in general, whether or not a given L-presentation is invariant, there is no algorithm which can determine the best possible underlying invariant L-presentation. The method implemented for this attribute tries to compute a ``good'' invariant L-presentation and will return the underlying ascending L-presentation in the worst case.

This attribute can be set manually using `SetUnderlyingInvariantLPresentation`. For instance, the Grigorchuk group

\[ \Big\langle a,b,c,d \Big| a^2,b^2,c^2,d^2,bcd,[d,d^a]^{\sigma^n}, [d,d^{acaca}]^{\sigma^n},(n\inℕ_0) \Big\rangle,\]

is invariantly L-presented and therefore, it should be constructed as follows:

    gap> F:=FreeGroup( "a", "b", "c", "d" );;
    gap> AssignGeneratorVariables( F );
    #I  Assigned the global variables [ a, b, c, d ]
    gap> frels:=[ a^2, b^2, c^2, d^2, b*c*d ];;
    gap> endos:=[ GroupHomomorphismByImagesNC( F, F, [ a, b, c, d ], [ c^a, d, b, c ]) ];;
    gap> irels:=[ Comm( d, d^a ), Comm( d, d^(a*c*a*c*a) ) ];;
    gap> G:=LPresentedGroup( F, frels, endos, irels );
    <L-presented group on the generators [ a, b, c, d ]>
    gap> SetUnderlyingInvariantLPresentation( G, G );;

##### 2.5-3 IsAscendingLPresentation

`‣ IsAscendingLPresentation`( lpgroup ) | ( property )

checks whether the L-presentation of lpgroup is ascending; that is, if the set of fixed relators is empty. This property is set automatically when creating an L-presented group with no fixed relators using the function `LPresentedGroup` (2.2-1).

##### 2.5-4 IsInvariantLPresentation

`‣ IsInvariantLPresentation`( lpgroup ) | ( property )

attempts to check whether the L-presentation of lpgroup is invariant. In general, one cannot decide whether or not a given L-presentation is invariant. There are mainly two methods implemented for this property. The first method seeks to find a ``good'' underlying invariant L-presentation using the operation `UnderlyingInvariantLPresentation` (2.5-2). If this latter L-presentation coincides with the L-presentation of lpgroup, then lpgroup is invariantly L-presented. If this method fails, then the second method uses the nilpotent quotient algorithm for L-presented groups which yields a necessary condition for an L-presented group to be invariantly L-presented. Note that the latter method may not terminate. For instance, both methods fail on Baumslag's finitely generated, infinitely related group with trivial multiplier returned by `ExamplesOfLPresentations` (2.2-2).

##### 2.5-5 EmbeddingOfAscendingSubgroup

`‣ EmbeddingOfAscendingSubgroup`( lpgroup ) | ( attribute )

stores an embedding of an ascendingly L-presented subgroup of the L-presented group lpgroup. This attribute is set for ascending L-presentations only. In this case, the identity map of lpgroup is returned. This attribute is used in the FR-package which can construct various finitely L-presented groups. The embedding is useful for a nilpotent quotient algorithm of a non-invariantly L-presented group.

#### 2.6 Methods for L-presented groups

Some operations are natural extensions of the operations for finitely generated groups. For example, `MappedWord(x,gens,imgs)`, when applied to a word `x` in an L-presented group, returns the group element obtained by replacing each occurrence of a generator in `gens` by the corresponding element in the list `imgs`. The lists `gens` and `imgs` need to have the same length.

Equality test of elements of L-presented groups is implemented using the operation `NqEpimorphismNilpotentQuotient` (nq: NqEpimorphismNilpotentQuotient) to compare the images in a nilpotent quotient of the group. The implemented method successively increases the class of the considered quotient until the images differ. Hence, this method may not terminate and it will only determine whether the elements are different.

##### 2.6-1 EpimorphismFromFpGroup

`‣ EpimorphismFromFpGroup`( lpgroup, n ) | ( operation )

returns an epimorphism from a finitely presented group onto lpgroup. The finitely presented group is obtained from lpgroup by applying only words of length at most n in the endomorphisms of lpgroup to the iterated relators of lpgroup.

##### 2.6-2 SplitExtensionByAutomorphismsLpGroup

`‣ SplitExtensionByAutomorphismsLpGroup`( lpgroup, H, auts ) | ( operation )

returns an L-presentation for the split extension of lpgroup by an L-presented or by a finitely presented group H. The action of a generator of H on lpgroup is given by an automorphism in the list auts. Thus for each generator of H there must be an automorphism in the list auts.

    gap> F := FreeGroup( "a" );
    <free group on the generators [ a ]>
    gap> H := F / [ F.1^3 ];
    <fp group on the generators [ a ]>
    gap> U := ExamplesOfLPresentations( 8 );
    <L-presented group on the generators [ t, u, v ]>
    gap> aut:=GroupHomomorphismByImagesNC( U, U, [ U.1, U.2, U.3 ], [ U.2, U.3, U.1 ] );
    [ t, u, v ] -> [ u, v, t ]
    gap> SplitExtensionByAutomorphismsLpGroup( U, H, [ aut ] );
    <L-presented group on the generators [ t, u, v, a ]>

##### 2.6-3 AsLpGroup

`‣ AsLpGroup`( G ) | ( operation )

returns an ascending L-presentation for a finitely presented group G or for a free group G.

##### 2.6-4 IsomorphismLpGroup

`‣ IsomorphismLpGroup`( G ) | ( operation )

returns an isomorphism from a finitely presented group G or from a free group G to the L-presented group obtained from the method `AsLpGroup` (2.6-3).

    gap> F:=FreeGroup( 2 );
    <free group on the generators [ f1, f2 ]>
    gap> G:=F/[ F.1^2, F.2^2, Comm( F.1, F.2 ) ];
    <fp group on the generators [ f1, f2 ]>
    gap> IsomorphismLpGroup( G );
    [ f1, f2 ] -> [ f1, f2 ]
    gap> Range(last);
    <L-presented group on the generators [ f1, f2 ]>
    gap> Display(last);
    generators = [ f1, f2 ]
    fixed relators = [ ]
    endomorphism = [
    IdentityMapping( <free group on the generators [ f1, f2 ]> ) ]
    iterated relators = [
    f1^2,
    f2^2,
    f1^-1*f2^-1*f1*f2 ]

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

generated by GAPDoc2HTML