GAP (XMod) - Chapter 2: 2d-groups : crossed modules and cat1-groups

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

2 2d-groups : crossed modules and cat1-groups
2.1 Constructions for crossed modules
2.1-1 XMod
2.1-2 Source
2.1-3 Size
2.1-4 IsXMod
2.1-5 SubXMod
2.2 Pre-crossed modules
2.2-1 PreXModByBoundaryAndAction
2.2-2 PeifferSubgroup
2.3 Cat1-groups and pre-cat1-groups
2.3-1 Source
2.3-2 Cat1
2.3-3 Cat1OfXMod
2.4 Selection of a small cat1-group
2.4-1 Cat1Select
2.4-2 AllCat1sBasic
2.5 More functions for crossed modules and cat1-groups
2.5-1 IdGroup

### 2 2d-groups : crossed modules and cat1-groups

#### 2.1 Constructions for crossed modules

A crossed module (of groups) mathcalX = (∂ : S -> R ) consists of a group homomorphism ∂, called the boundary of mathcalX, with source S and range R. The group R acts on itself by conjugation, and on S by an action α : R -> Aut(S) such that, for all s,s_1,s_2 ∈ S and r ∈ R,

{\bf XMod\ 1} : \partial(s^r) = r^{-1} (\partial s) r = (\partial s)^r, \qquad {\bf XMod\ 2} : s_1^{\partial s_2} = s_2^{-1}s_1 s_2 = {s_1}^{s_2}.

When only the first of these axioms is satisfied, the resulting structure is a pre-crossed module (see section 2.2). (Much of the literature on crossed modules uses left actions, but we have chosen to use right actions in this package since that is the standard choice for group actions in GAP.)

The kernel of ∂ is abelian.

There are a variety of constructors for crossed modules:

##### 2.1-1 XMod

`‣ XMod`( args ) | ( function )

`‣ XModByBoundaryAndAction`( bdy, act ) | ( operation )

`‣ XModByTrivialAction`( bdy ) | ( operation )

`‣ XModByNormalSubgroup`( G, N ) | ( operation )

`‣ XModByCentralExtension`( bdy ) | ( operation )

`‣ XModByAutomorphismGroup`( grp ) | ( operation )

`‣ XModByInnerAutomorphismGroup`( grp ) | ( operation )

`‣ XModByGroupOfAutomorphisms`( G, A ) | ( operation )

`‣ XModByAbelianModule`( abmod ) | ( operation )

`‣ DirectProduct`( X1, X2 ) | ( operation )

The global function `XMod` implements one of the following standard constructions:

- A trivial action crossed module (∂ : S -> R) has s^r = s for all s ∈ S, r ∈ R, the source is abelian and the image lies in the centre of the range.

- A conjugation crossed module is the inclusion of a normal subgroup S ⊴ R, where R acts on S by conjugation.

- A central extension crossed module has as boundary a surjection ∂ : S -> R, with central kernel, where r ∈ R acts on S by conjugation with ∂^-1r.

- An automorphism crossed module has as range a subgroup R of the automorphism group Aut(S) of S which contains the inner automorphism group of S. The boundary maps s ∈ S to the inner automorphism of S by s.

- A crossed abelian module has an abelian module as source and the zero map as boundary.

- The direct product mathcalX_1 × mathcalX_2 of two crossed modules has source S_1 × S_2, range R_1 × R_2 and boundary ∂_1 × ∂_2, with R_1, R_2 acting trivially on S_2, S_1 respectively.

##### 2.1-2 Source

`‣ Source`( X0 ) | ( attribute )

`‣ Range`( X0 ) | ( attribute )

`‣ Boundary`( X0 ) | ( attribute )

`‣ AutoGroup`( X0 ) | ( attribute )

`‣ XModAction`( X0 ) | ( attribute )

The following attributes are used in the construction of a crossed module `X0`.

- `Source(X0)` and `Range(X0)` are the source S and range R of ∂, the boundary `Boundary(X0)`;

- `AutoGroup(X0)` is a group of automorphisms of S;

- `XModAction(X0)` is a homomorphism from R to `AutoGroup(X0)`.

##### 2.1-3 Size

`‣ Size`( X0 ) | ( attribute )

`‣ Name`( X0 ) | ( attribute )

`‣ IdGroup`( X0 ) | ( attribute )

`‣ ExternalSetXMod`( X0 ) | ( attribute )

More familiar attributes are `Name`, `Size` and `IdGroup`. The name is formed by concatenating the names of the source and range (if these exist). `Size` and `IdGroup` return two-element lists.

The `ExternalSetXMod"` for a crossed module is the source group considered as a G-set of the range group using the crossed module action.

The `Display` function is used to print details of 2d-groups.

In the simple example below, `X1` is an automorphism crossed module, using a cyclic group of size five. The `Print` statements at the end list the GAP representations, properties and attributes of `X1`.

    gap> c5 := Group( (5,6,7,8,9) );;
    gap> SetName( c5, "c5" );
    gap> X1 := XModByAutomorphismGroup( c5 );
    [c5 -> PAut(c5)]
    gap> Display( X1 );
    Crossed module [c5 -> PAut(c5)] :-
    : Source group c5 has generators:
      [ (5,6,7,8,9) ]
    : Range group PAut(c5) has generators:
      [ (1,2,3,4) ]
    : Boundary homomorphism maps source generators to:
      [ () ]
    : Action homomorphism maps range generators to automorphisms:
      (1,2,3,4) --> { source gens --> [ (5,7,9,6,8) ] }
      This automorphism generates the group of automorphisms.
    gap> Size( X1 );  IdGroup( X1 );
    [ 5, 4 ]
    [ [ 5, 1 ], [ 4, 1 ] ]
    gap> ext := ExternalSetXMod( X1 );
    <xset:[ (), (5,6,7,8,9), (5,7,9,6,8), (5,8,6,9,7), (5,9,8,7,6) ]>
    gap> Orbits( ext );
    [ [ () ], [ (5,6,7,8,9), (5,7,9,6,8), (5,9,8,7,6), (5,8,6,9,7) ] ]
    gap> RepresentationsOfObject( X1 );
    [ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPreXModObj" ]
    gap> KnownPropertiesOfObject( X1 );
    [ "IsEmpty", "IsTrivial", "IsNonTrivial", "IsFinite",
      "CanEasilyCompareElements", "CanEasilySortElements", "IsDuplicateFree",
      "IsGeneratorsOfSemigroup", "IsPreXModDomain", "IsPerm2dGroup", "IsPreXMod",
      "IsXMod", "IsAutomorphismGroup2dGroup" ]
    gap> KnownAttributesOfObject( X1);
    [ "Name", "Size", "Range", "Source", "IdGroup", "Boundary", "AutoGroup",
      "XModAction", "ExternalSetXMod" ]

##### 2.1-4 IsXMod

`‣ IsXMod`( X0 ) | ( property )

`‣ IsPreXMod`( X0 ) | ( property )

`‣ IsPerm2dGroup`( X0 ) | ( property )

`‣ IsPc2dGroup`( X0 ) | ( property )

`‣ IsFp2dGroup`( X0 ) | ( property )

The underlying category structures for the objects constructed in this chapter follow the sequence `Is2dDomain`; `Is2dMagma`; `Is2dMagmaWithOne`; `Is2dMagmaWithInverses`, mirroring the situation for (one-dimensional) groups. From these we construct `Is2dSemigroup`, `Is2dMonoid` and `Is2dGroup`.

A structure which has `IsPerm2dGroup` is a precrossed module or a pre-cat1-group (see section 2.3) whose source and range are both permutation groups. The properties `IsPc2dGroup`, `IsFp2dGroup` are defined similarly. We see in the previous example that `X1` has `IsPreXMod`, `IsXMod` and `IsPerm2dGroup`. There are also properties corresponding to the various construction methods listed in section 2.1: `IsTrivialAction2dGroup`; `IsNormalSubgroup2dGroup`; `IsCentralExtension2dGroup`; `IsAutomorphismGroup2dGroup`; `IsAbelianModule2dGroup`.

##### 2.1-5 SubXMod

`‣ SubXMod`( X0, src, rng ) | ( operation )

`‣ TrivialSubXMod`( X0 ) | ( attribute )

`‣ NormalSubXMods`( X0 ) | ( attribute )

With the standard crossed module constructors listed above as building blocks, sub-crossed modules, normal sub-crossed modules mathcalN ⊲ mathcalX, and also quotients mathcalX/mathcalN may be constructed. A sub-crossed module mathcalS = (δ : N -> M) is normal in mathcalX = (∂ : S -> R) if

- N,M are normal subgroups of S,R respectively,

- δ is the restriction of ∂,

- n^r ∈ N for all n ∈ N,~r ∈ R,

- (s^-1)^ms ∈ N for all m ∈ M,~s ∈ S.

These conditions ensure that M ⋉ N is normal in the semidirect product R ⋉ S. (Note that ⟨ s,m ⟩ = (s^-1)^ms is a displacement: see `Displacement` (4.1-3).)

A method for `IsNormal` for crossed modules is provided. See section 4.1 for quotient crossed modules and natural homomorphisms.

The five normal subcrossed modules of `X4` found in the following example are `[id,id], [k4,k4], [k4,a4], [a4,a4]` and `X4` itself.

    gap> s4 := Group( (1,2), (2,3), (3,4) );;
    gap> a4 := Subgroup( s4, [ (1,2,3), (2,3,4) ] );;
    gap> k4 := Subgroup( a4, [ (1,2)(3,4), (1,3)(2,4) ] );;
    gap> SetName(s4,"s4");  SetName(a4,"a4");  SetName(k4,"k4");
    gap> X4 := XModByNormalSubgroup( s4, a4 );
    [a4->s4]
    gap> Y4 := SubXMod( X4, k4, a4 );
    [k4->a4]
    gap> IsNormal(X4,Y4);
    true
    gap> NX4 := NormalSubXMods( X4 );;
    gap> Length( NX4 );
    5

#### 2.2 Pre-crossed modules

##### 2.2-1 PreXModByBoundaryAndAction

`‣ PreXModByBoundaryAndAction`( bdy, act ) | ( operation )

`‣ SubPreXMod`( X0, src, rng ) | ( operation )

If axiom XMod 2 is not satisfied, the corresponding structure is known as a pre-crossed module.

    gap> b1 := (11,12,13,14,15,16,17,18);;  b2 := (12,18)(13,17)(14,16);;
    gap> d16 := Group( b1, b2 );;
    gap> sk4 := Subgroup( d16, [ b1^4, b2 ] );;
    gap> SetName( d16, "d16" );  SetName( sk4, "sk4" );
    gap> bdy16 := GroupHomomorphismByImages( d16, sk4, [b1,b2], [b1^4,b2] );;
    gap> aut1 := GroupHomomorphismByImages( d16, d16, [b1,b2], [b1^5,b2] );;
    gap> aut2 := GroupHomomorphismByImages( d16, d16, [b1,b2], [b1,b2^4*b2] );;
    gap> aut16 := Group( [ aut1, aut2 ] );;
    gap> act16 := GroupHomomorphismByImages( sk4, aut16, [b1^4,b2], [aut1,aut2] );;
    gap> P16 := PreXModByBoundaryAndAction( bdy16, act16 );
    [d16->sk4]
    gap> IsXMod(P16);
    false

##### 2.2-2 PeifferSubgroup

`‣ PeifferSubgroup`( X0 ) | ( attribute )

`‣ XModByPeifferQuotient`( prexmod ) | ( attribute )

The Peiffer subgroup of a pre-crossed module P of S is the subgroup of ker(∂) generated by Peiffer commutators

\lfloor s_1,s_2 \rfloor ~=~ (s_1^{-1})^{\partial s_2}~s_2^{-1}~s_1~s_2 ~=~ \langle \partial s_2, s_1 \rangle\ [s_1,s_2]~.

Then mathcalP = (0 : P -> {1_R}) is a normal sub-pre-crossed module of mathcalX and mathcalX/mathcalP = (∂ : S/P -> R) is a crossed module.

In the following example the Peiffer subgroup is cyclic of size 4.

    gap> P := PeifferSubgroup( P16 );
    Group( [ (11,15)(12,16)(13,17)(14,18), (11,17,15,13)(12,18,16,14) ] )
    gap> X16 := XModByPeifferQuotient( P16 );
    [D16/P->sk4]
    gap> Display( X16 );
    Crossed module [D16/P->sk4] :-
    : Source group has generators:
      [ f1, f2 ]
    : Range group has generators:
      [ (11,15)(12,16)(13,17)(14,18), (12,18)(13,17)(14,16) ]
    : Boundary homomorphism maps source generators to:
      [ (12,18)(13,17)(14,16), (11,15)(12,16)(13,17)(14,18) ]
      The automorphism group is trivial
    gap> iso16 := IsomorphismPermGroup( Source( X16 ) );;
    gap> S16 := Image( iso16 );
    Group([ (1,2), (3,4) ])

#### 2.3 Cat1-groups and pre-cat1-groups

##### 2.3-1 Source

`‣ Source`( C ) | ( attribute )

`‣ Range`( C ) | ( attribute )

`‣ TailMap`( C ) | ( attribute )

`‣ HeadMap`( C ) | ( attribute )

`‣ RangeEmbedding`( C ) | ( attribute )

`‣ KernelEmbedding`( C ) | ( attribute )

`‣ Boundary`( C ) | ( attribute )

`‣ Name`( C ) | ( attribute )

`‣ Size`( C ) | ( attribute )

These are the attributes of a cat1-group mathcalC in this implementation.

In [Lod82], Loday reformulated the notion of a crossed module as a cat1-group, namely a group G with a pair of homomorphisms t,h : G -> G having a common image R and satisfying certain axioms. We find it convenient to define a cat1-group mathcalC = (e;t,h : G -> R ) as having source group G, range group R, and three homomorphisms: two surjections t,h : G -> R and an embedding e : R -> G satisfying:

{\bf Cat\ 1} : ~t \circ e ~=~ h \circ e = {\rm id}_R, \qquad {\bf Cat\ 2} : ~[\ker t, \ker h] ~=~ \{ 1_G \}.

It follows that ~t ∘ e ∘ h = h,~ h ∘ e ∘ t = t, ~t ∘ e ∘ t = t,~ h ∘ e ∘ h = h.

The maps t,h are often referred to as the source and target, but we choose to call them the tail and head of mathcalC, because source is the GAP term for the domain of a function. The `RangeEmbedding` is the embedding of `R` in `G`, the `KernelEmbedding` is the inclusion of the kernel of `t` in `G`, and the `Boundary` is the restriction of `h` to the kernel of `t`.

##### 2.3-2 Cat1

`‣ Cat1`( args ) | ( attribute )

`‣ PreCat1ByTailHeadEmbedding`( t, h, e ) | ( attribute )

`‣ PreCat1ByEndomorphisms`( t, h ) | ( attribute )

`‣ PreCat1ByNormalSubgroup`( G, N ) | ( attribute )

`‣ Cat1ByPeifferQuotient`( P ) | ( attribute )

`‣ Reverse`( C0 ) | ( attribute )

These are some of the constructors for pre-cat1-groups and cat1-groups. The following listing shows an example of a cat1-group of pc-groups of size [28,12].

    gap> G2 := SmallGroup( 288, 956 );  SetName( G2, "G2" );
    <pc group of size 288 with 7 generators>
    gap> d12 := DihedralGroup( 12 );  SetName( d12, "d12" );
    <pc group of size 12 with 3 generators>
    gap> a1 := d12.1;;  a2 := d12.2;;  a3 := d12.3;;  a0 := One( d12 );;
    gap> gensG2 := GeneratorsOfGroup( G2 );;
    gap> t2 := GroupHomomorphismByImages( G2, d12, gensG2,
    >           [ a0, a1*a3, a2*a3, a0, a0, a3, a0 ] );;
    gap> h2 := GroupHomomorphismByImages( G2, d12, gensG2,
    >           [ a1*a2*a3, a0, a0, a2*a3, a0, a0, a3^2 ] );;
    gap> e2 := GroupHomomorphismByImages( d12, G2, [a1,a2,a3],
    >        [ G2.1*G2.2*G2.4*G2.6^2, G2.3*G2.4*G2.6^2*G2.7, G2.6*G2.7^2 ] );
    [ f1, f2, f3 ] -> [ f1*f2*f4*f6^2, f3*f4*f6^2*f7, f6*f7^2 ]
    gap> C2 := PreCat1ByTailHeadEmbedding( t2, h2, e2 );
    [G2=>d12]
    gap> IsCat1( C2 );
    true
    gap> Display(C2);

    Cat1-group [G2=>d12] :-
    : Source group G2 has generators:
      [ f1, f2, f3, f4, f5, f6, f7 ]
    : Range group d12 has generators:
      [ f1, f2, f3 ]
    : tail homomorphism maps source generators to:
      [ <identity> of ..., f1*f3, f2*f3, <identity> of ..., <identity> of ...,
      f3, <identity> of ... ]
    : head homomorphism maps source generators to:
      [ f1*f2*f3, <identity> of ..., <identity> of ..., f2*f3, <identity> of ...,
      <identity> of ..., f3^2 ]
    : range embedding maps range generators to:
      [ f1*f2*f4*f6^2, f3*f4*f6^2*f7, f6*f7^2 ]
    : kernel has generators:
      [ f1, f4, f5, f7 ]
    : boundary homomorphism maps generators of kernel to:
      [ f1*f2*f3, f2*f3, <identity> of ..., f3^2 ]
    : kernel embedding maps generators of kernel to:
      [ f1, f4, f5, f7 ]

##### 2.3-3 Cat1OfXMod

`‣ Cat1OfXMod`( X0 ) | ( attribute )

`‣ XModOfCat1`( C0 ) | ( attribute )

`‣ PreCat1OfPreXMod`( P0 ) | ( attribute )

`‣ PreXModOfPreCat1`( P0 ) | ( attribute )

The category of crossed modules is equivalent to the category of cat1-groups, and the functors between these two categories may be described as follows. Starting with the crossed module mathcalX = (∂ : S -> R) the group G is defined as the semidirect product G = R ⋉ S using the action from mathcalX, with multiplication rule

(r_1,s_1)(r_2,s_2) ~=~ (r_1r_2,{s_1}^{r_2}s_2).

The structural morphisms are given by

t(r,s) = r, \quad h(r,s) = r (\partial s), \quad er = (r,1).

On the other hand, starting with a cat1-group mathcalC = (e;t,h : G -> R), we define S = ker t, the range R is unchanged, and ∂ = h∣_S. The action of R on S is conjugation in G via the embedding of R in G.

    gap> X2 := XModOfCat1( C2 );;
    gap> Display( X2 );

    Crossed module X([G2=>d12]) :-
    : Source group has generators:
      [ f1, f4, f5, f7 ]
    : Range group d12 has generators:
      [ f1, f2, f3 ]
    : Boundary homomorphism maps source generators to:
      [ f1*f2*f3, f2*f3, <identity> of ..., f3^2 ]
    : Action homomorphism maps range generators to automorphisms:
      f1 --> { source gens --> [ f1*f5, f4*f5, f5, f7^2 ] }
      f2 --> { source gens --> [ f1*f5*f7^2, f4, f5, f7 ] }
      f3 --> { source gens --> [ f1*f7, f4, f5, f7 ] }
      These 3 automorphisms generate the group of automorphisms.
    : associated cat1-group is [G2=>d12]

    gap> StructureDescription(X2);
    [ "D24", "D12" ]

#### 2.4 Selection of a small cat1-group

The `Cat1` function may also be used to select a cat1-group from a data file. All cat1-structures on groups of size up to 70 (ordered according to the GAP 4 numbering of small groups) are stored in a list in file `cat1data.g`. Global variables `CAT1_LIST_MAX_SIZE := 70` and `CAT1_LIST_CLASS_SIZES` are also stored. The data is read into the list `CAT1_LIST` only when this function is called.

##### 2.4-1 Cat1Select

`‣ Cat1Select`( size, gpnum, num ) | ( attribute )

The function `Cat1Select` may be used in three ways. `Cat1Select( size )` returns the names of the groups with this size, while `Cat1Select( size, gpnum )` prints a list of cat1-structures for this chosen group. `Cat1Select( size, gpnum, num )` returns the chosen cat1-group.

The example below is the first case in which t ≠ h and the associated conjugation crossed module is given by the normal subgroup `c3` of `s3`.

    gap> ## check the number of groups of size 18
    gap> L18 := Cat1Select( 18 );
    Usage:  Cat1Select( size, gpnum, num );
    [ "D18", "C18", "C3 x S3", "(C3 x C3) : C2", "C6 x C3" ]
    gap> ## check the number of cat1-structrues on the fourth of these
    gap> Cat1Select( 18, 4 );
    Usage:  Cat1Select( size, gpnum, num );
    There are 4 cat1-structures for the group (C3 x C3) : C2.
    Using small generating set [ f1, f2, f2*f3 ] for source of homs.
    [ [range gens], [tail genimages], [head genimages] ] :-
    (1)  [ [ f1 ], [ f1, <identity> of ..., <identity> of ... ],
      [ f1, <identity> of ..., <identity> of ... ] ]
    (2)  [ [ f1, f3 ], [ f1, <identity> of ..., f3 ],
      [ f1, <identity> of ..., f3 ] ]
    (3)  [ [ f1, f3 ], [ f1, <identity> of ..., f3 ],
      [ f1, f3^2, <identity> of ... ] ]
    (4)  [ [ f1, f2, f2*f3 ],  tail = head = identity mapping ]
    4
    gap> ## select the third of these cat1-structures
    gap> C18 := Cat1( 18, 4, 3 );
    [(C3 x C3) : C2=>Group( [ f1, <identity> of ..., f3 ] )]
    gap> ## convert from a pc-cat1-group to a permutation cat1-group
    gap> iso18 := IsomorphismPermObject( C18 );;
    gap> PC18 := Image( iso18 );;
    gap> Display( PC18 );
    Cat1-group :-
    : Source group has generators:
      [ (2,3)(5,6), (4,5,6), (1,2,3) ]
    : Range group has generators:
      [ (2,3), (), (1,2,3) ]
    : tail homomorphism maps source generators to:
      [ (2,3), (), (1,2,3) ]
    : head homomorphism maps source generators to:
      [ (2,3), (1,3,2), (1,2,3) ]
    : range embedding maps range generators to:
      [ (2,3)(5,6), (), (1,2,3) ]
    : kernel has generators:
      [ (4,5,6) ]
    : boundary homomorphism maps generators of kernel to:
      [ (1,3,2) ]
    : kernel embedding maps generators of kernel to:
      [ (4,5,6) ]
    gap> convert the result to the associated permutation crossed module
    gap> X18 := XModByCat1( PC18 );;
    gap> Display( X18 );
    Crossed module:-
    : Source group has generators:
      [ (4,5,6) ]
    : Range group has generators:
      [ (2,3), (), (1,2,3) ]
    : Boundary homomorphism maps source generators to:
      [ (1,3,2) ]
    : Action homomorphism maps range generators to automorphisms:
      (2,3) --> { source gens --> [ (4,6,5) ] }
      () --> { source gens --> [ (4,5,6) ] }
      (1,2,3) --> { source gens --> [ (4,5,6) ] }
      These 3 automorphisms generate the group of automorphisms.
    : associated cat1-group is [..=>..]

##### 2.4-2 AllCat1sBasic

`‣ AllCat1sBasic`( gp ) | ( operation )

For a group G of size greater than 70 which is reasonably straightforward this function may be used to construct a list of all cat1-group structures on G. The operation also attempts to write output to a file in the folder `xmod/lib`. (Other operations in the file `cat1data.gi` have been used to deal with the more complicated groups of size up to 70, but these are not described here.)

Van Luyen Le has a more efficient algorithm, extending the data up to groups of size 171, which is expected to appear in a future release of HAP.

    gap> gp := SmallGroup( 102, 2 );
    <pc group of size 102 with 3 generators>
    gap> StructureDescription( gp );
    "C3 x D34"
    gap> all := AllCat1sBasic( gp );
    #I Edit last line of .../xmod/lib/nn.kk.out to end with ] ] ] ] ]
    [ [Group( [ f1, f2, f3 ] )=>Group( [ f1, <identity> of ..., <identity> of ...
         ] )], [Group( [ f1, f2, f3 ] )=>Group( [ f1, f2, <identity> of ... ] )],
      [Group( [ f1, f2, f3 ] )=>Group( [ f1, <identity> of ..., f3 ] )],
      [Group( [ f1, f2, f3 ] )=>Group( [ f1, f2, f3 ] )] ]

#### 2.5 More functions for crossed modules and cat1-groups

Chapter 4 contains functions for quotient crossed modules; centre of a crossed module; commutator and derived subcrossed modules; etc.

Here we mention two functions for groups which have been extended to the two-dimensional case.

##### 2.5-1 IdGroup

`‣ IdGroup`( 2dgroup ) | ( operation )

`‣ StructureDescription`( 2dgroup ) | ( operation )

These functions return two-element lists formed by applying the function to the source and range of the 2d-group.

    gap> IdGroup( X16 );
    [ [ 8, 3 ], [ 16, 7 ] ]
    gap> StructureDescription( C2 );
    [ "(S3 x d24) : C2", "d12" ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 Bib Ind

generated by GAPDoc2HTML