GAP (XMod) - Chapter 4: Isoclinism of groups and crossed modules

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

[MathJax on]

4 Isoclinism of groups and crossed modules
4.1 More operations for crossed modules
4.1-1 FactorPreXMod
4.1-2 IntersectionSubXMods
4.1-3 Displacement
4.1-4 CommutatorSubXMod
4.1-5 DerivedSubXMod
4.1-6 FixedPointSubgroupXMod
4.1-7 CentreXMod
4.1-8 CentralQuotient
4.1-9 IsAbelian2DimensionalGroup
4.1-10 LowerCentralSeriesOfXMod
4.1-11 AllXMods
4.1-12 IsomorphismXMods
4.2 Isoclinism for groups
4.2-1 Isoclinism
4.2-2 IsStemDomain
4.2-3 IsoclinicRank
4.3 Isoclinism for crossed modules
4.3-1 Isoclinism
4.3-2 IsStemDomain
4.3-3 IsoclinicRank

### 4 Isoclinism of groups and crossed modules

This chapter describes some functions written by Alper Odabaş and Enver Uslu, and reported in their paper [IOU16]. Section 4.1 contains some additional basic functions for crossed modules, constructing quotients, centres, centralizers and normalizers. In Sections 4.2 and 4.3 there are functions dealing specifically with isoclinism for groups and for crossed modules. Since these functions represent a recent addition to the package (as of November 2015), the function names are liable to change in future versions. The notion of isoclinism has been crucial to the enumeration of groups of prime power order, see for example James, Newman and O'Brien, [JNO90].

#### 4.1 More operations for crossed modules

##### 4.1-1 FactorPreXMod

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

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

When calX_2 = (∂_2 : S_2 -> R_2) is a normal sub-precrossed module of calX_1 = (∂_1 : S_1 -> R_1), then the quotient precrossed module is (∂ : S_2/S_1 -> R_2/R_1) with the induced boundary and action maps. Quotienting a precrossed module by it's Peiffer subgroup is a special case of this construction. (Permutation representations vary between different versions of GAP.)

    gap> d24 := DihedralGroup( IsPermGroup, 24 );;
    gap> SetName( d24, "d24" );
    gap> Y24 := XModByAutomorphismGroup( d24 );;
    gap> Size( Y24 );
    [ 24, 48 ]
    gap> X24 := Image( IsomorphismPerm2DimensionalGroup( Y24 ) );
    [d24->Group([ (2,4), (1,2,3,4), (6,7), (5,6,7) ])]
    gap> nsx := NormalSubXMods( X24 );;
    gap> Length( nsx );
    40
    gap> ids := List( nsx, n -> IdGroup(n) );;
    gap> pos1 := Position( ids, [ [4,1], [8,3] ] );;
    gap> Xn1 := nsx[pos1];
    [Group( [ f2*f4^2, f3*f4 ] )->Group( [ f3, f4, f5 ] )]
    gap> nat1 := NaturalMorphismByNormalSubPreXMod( X24, Xn1 );;
    gap> Qn1 := FactorPreXMod( X24, Xn1 );;
    gap> [ Size( Xn1 ), Size( Qn1 ) ];
    [ [ 4, 8 ], [ 6, 6 ] ]

##### 4.1-2 IntersectionSubXMods

`‣ IntersectionSubXMods`( X0, X1, X2 ) | ( operation )

When `X1,X2` are subcrossed modules of `X0`, then the source and range of their intersection are the intersections of the sources and ranges of `X1` and `X2` respectively.

    gap> pos2 := Position( ids, [ [24,6], [12,4] ] );;
    gap> Xn2 := nsx[pos2];;
    gap> IdGroup( Xn2 );
    [ [ 24, 6 ], [ 12, 4 ] ]
    gap> pos3 := Position( ids, [ [12,2], [24,5] ] );;
    gap> Xn3 := nsx[pos3];;
    gap> IdGroup( Xn3 );
    [ [ 12, 2 ], [ 24, 5 ] ]
    gap> Xn23 := IntersectionSubXMods( X24, Xn2, Xn3 );;
    gap> IdGroup( Xn23 );
    [ [ 12, 2 ], [ 6, 2 ] ]

##### 4.1-3 Displacement

`‣ Displacement`( alpha, r, s ) | ( operation )

`‣ DisplacementGroup`( X0, Q, T ) | ( operation )

`‣ DisplacementSubgroup`( X0 ) | ( attribute )

Commutators may be written [r,q] = r^-1q^-1rq = (q^-1)^rq = r^-1r^q, and satisfy identities

[r,q]^p = [r^p,q^p], \qquad [pr,q] = [p,q]^r[r,q], \qquad [r,pq] = [r,q][r,p]^q, \qquad [r,q]^{-1} = [q,r].

In a similar way, when a group R acts on a group S, the displacement of s ∈ S by r ∈ R is defined to be ⟨ r,s ⟩ := (s^-1)^rs ∈ S. When calX = (∂ : S -> R) is a pre-crossed module, the first crossed module axiom requires ∂⟨ r,s ⟩ = [r,∂ s]. When α is the action of calX, the `Displacement` function may be used to calculate ⟨ r,s ⟩. Displacements satisfy the following identities, where s,t ∈ S,~ p,q,r ∈ R:

\langle r,s \rangle^p = \langle r^p,s^p \rangle, \qquad \langle qr,s \rangle = \langle q,s \rangle^r \langle r,s \rangle, \qquad \langle r,st \rangle = \langle r,t \rangle \langle r,s \rangle^t, \qquad \langle r,s \rangle^{-1} = \langle r^{-1},s^r \rangle.

The operation `DisplacementGroup` applied to `X0,Q,T` is the subgroup of `S` consisting of all the displacements ⟨ r,s ⟩, r ∈ Q leqslant R, s ∈ T leqslant S. The `DisplacementSubgroup` of calX is the subgroup Disp(calX) of S given by `DisplacementGroup(X0,R,S)`. The identities imply ⟨ r,s ⟩^t = ⟨ r,st^r^-1} ⟩ ⟨ r^-1,t ⟩, so Disp(calX) is normal in S.

    gap> pos4 := Position( ids, [ [6,2], [24,14] ] );;
    gap> Xn4 := nsx[pos4];;
    gap> bn4 := Boundary( Xn4 );;
    gap> Sn4 := Source(Xn4);;
    gap> Rn4 := Range(Xn4);;
    gap> genRn4 := GeneratorsOfGroup( Rn4 );;
    gap> L := List( genRn4, g -> ( Order(g) = 2 ) and
    >                 not ( IsNormal( Rn4, Subgroup( Rn4, [g] ) ) ) );;
    gap> pos := Position( L, true );;
    gap> s := Sn4.1;  r := genRn4[pos];
    (1,3,5,7,9,11)(2,4,6,8,10,12)
    (6,7)
    gap> act := XModAction( Xn4 );;
    gap> d := Displacement( act, r, s );
    (1,5,9)(2,6,10)(3,7,11)(4,8,12)
    gap> Image( bn4, d ) = Comm( r, Image( bn4, s ) );
    true
    gap> Qn4 := Subgroup( Rn4, [ (6,7), (1,3), (2,4) ] );;
    gap> Tn4 := Subgroup( Sn4, [ (1,3,5,7,9,11)(2,4,6,8,10,12) ] );;
    gap> DisplacementGroup( Xn4, Qn4, Tn4 );
    Group([ (1,5,9)(2,6,10)(3,7,11)(4,8,12) ])
    gap> DisplacementSubgroup( Xn4 );
    Group([ (1,5,9)(2,6,10)(3,7,11)(4,8,12) ])

##### 4.1-4 CommutatorSubXMod

`‣ CommutatorSubXMod`( X, X1, X2 ) | ( operation )

`‣ CrossActionSubgroup`( X, X1, X2 ) | ( operation )

When calX_1 = (N -> Q), calX_2 = (M -> P) are two normal subcrossed modules of calX = (∂ : S -> R), the displacements ⟨ p,n ⟩ and ⟨ q,m ⟩ all map by ∂ into [Q,P]. These displacements form a normal subgroup of S, called the `CrossActionSubgroup`. The `CommutatorSubXMod` [calX_1,calX_2] has this subgroup as source and [P,Q] as range, and is normal in calX.

    gap> CAn23 := CrossActionSubgroup( X24, Xn2, Xn3 );;
    gap> IdGroup( CAn23 );
    [ 12, 2 ]
    gap> Cn23 := CommutatorSubXMod( X24, Xn2, Xn3 );;
    gap> IdGroup( Cn23 );
    [ [ 12, 2 ], [ 6, 2 ] ]
    gap> Xn23 = Cn23;
    true

##### 4.1-5 DerivedSubXMod

`‣ DerivedSubXMod`( X0 ) | ( attribute )

The `DerivedSubXMod` of calX is the normal subcrossed module [calX,calX] = (∂' : Disp(calX) -> [R,R]) where ∂' is the restriction of ∂ (see page 66 of Norrie's thesis [Nor87]).

    gap> DXn4 := DerivedSubXMod( Xn4 );;
    gap> IdGroup( DXn4 );
    [ [ 3, 1 ], [ 3, 1 ] ]

##### 4.1-6 FixedPointSubgroupXMod

`‣ FixedPointSubgroupXMod`( X0, T, Q ) | ( operation )

`‣ StabilizerSubgroupXMod`( X0, T, Q ) | ( operation )

The `FixedPointSubgroupXMod(X,T,Q)` for calX=(∂ : S -> R) is the subgroup Fix(calX,T,Q) of elements t ∈ T leqslant S individually fixed under the action of Q leqslant R.

The `StabilizerSubgroupXMod(X,T,Q)` for calX is the subgroup Stab(calX,T,Q) of Q leqslant R whose elements act trivially on the whole of T leqslant S (see page 19 of Norrie's thesis [Nor87]).

    gap> fix := FixedPointSubgroupXMod( Xn4, Sn4, Rn4 );
    Group([ (1,7)(2,8)(3,9)(4,10)(5,11)(6,12) ])
    gap> stab := StabilizerSubgroupXMod( Xn4, Sn4, Rn4 );;
    gap> IdGroup( stab );
    [ 12, 5 ]

##### 4.1-7 CentreXMod

`‣ CentreXMod`( X0 ) | ( attribute )

`‣ Centralizer`( X, Y ) | ( operation )

`‣ Normalizer`( X, Y ) | ( operation )

The centre Z(calX) of calX = (∂ : S -> R) has as source the fixed point subgroup Fix(calX,S,R). The range is the intersection of the centre Z(R) with the stabilizer subgroup.

When calY = (T -> Q) is a subcrossed module of calX = (∂ : S -> R), the centralizer C_calX(calY) of calY has as source the fixed point subgroup Fix(calX,S,Q). The range is the intersection of the centralizer C_R(Q) with Stab(calX,T,R).

The normalizer N_calX(calY) of calY has as source the subgroup of S consisting of the displacements ⟨ s,q ⟩ which lie in S.

    gap> ZXn4 := CentreXMod( Xn4 );
    [Group( [ f3*f4 ] )->Group( [ f3, f5 ] )]
    gap> IdGroup( ZXn4 );
    [ [ 2, 1 ], [ 4, 2 ] ]
    gap> CDXn4 := Centralizer( Xn4, DXn4 );
    [Group( [ f3*f4 ] )->Group( [ f2 ] )]
    gap> IdGroup( CDXn4 );
    [ [ 2, 1 ], [ 3, 1 ] ]
    gap> NDXn4 := Normalizer( Xn4, DXn4 );
    [Group( <identity> of ... )->Group( [ f5, f2*f3 ] )]
    gap> IdGroup( NDXn4 );
    [ [ 1, 1 ], [ 12, 5 ] ]

##### 4.1-8 CentralQuotient

`‣ CentralQuotient`( G ) | ( attribute )

The `CentralQuotient` of a group G is the crossed module (G -> G/Z(G)) with the natural homomorphism as the boundary map. This is a special case of `XModByCentralExtension` (2.1-5).

Similarly, the central quotient of a crossed module calX is the crossed square (calX ⇒ calX/Z(calX)) (see section 8.2).

    gap> Q24 := CentralQuotient( d24);  IdGroup( Q24 );
    [d24->d24/Z(d24)]
    [ [ 24, 6 ], [ 12, 4 ] ]

##### 4.1-9 IsAbelian2DimensionalGroup

`‣ IsAbelian2DimensionalGroup`( X0 ) | ( property )

`‣ IsAspherical2DimensionalGroup`( X0 ) | ( property )

`‣ IsSimplyConnected2DimensionalGroup`( X0 ) | ( property )

`‣ IsFaithful2DimensionalGroup`( X0 ) | ( property )

A crossed module is abelian if it equal to its centre. This is the case when the range group is abelian and the action is trivial.

A crossed module is aspherical if the boundary has trivial kernel.

A crossed module is simply connected if the boundary has trivial cokernel.

A crossed module is faithful if the action is faithful.

    gap> [ IsAbelian2DimensionalGroup(Xn4), IsAbelian2DimensionalGroup(X24) ];

    [ false, false ]
    gap> pos7 := Position( ids, [ [3,1], [6,1] ] );;

    gap> [ IsAspherical2DimensionalGroup(nsx[pos7]), IsAspherical2DimensionalGroup(X24) ];

    [ true, false ]
    gap> [ IsSimplyConnected2DimensionalGroup(Xn4), IsSimplyConnected2DimensionalGroup(X24) ];
    [ true, true ]
    gap> [ IsFaithful2DimensionalGroup(Xn4), IsFaithful2DimensionalGroup(X24) ];
    [ false, true ]

##### 4.1-10 LowerCentralSeriesOfXMod

`‣ LowerCentralSeriesOfXMod`( X0 ) | ( attribute )

`‣ IsNilpotent2DimensionalGroup`( X0 ) | ( property )

`‣ NilpotencyClass2DimensionalGroup`( X0 ) | ( attribute )

Let calY be a subcrossed module of calX. A series of length n from calX to calY has the form

\calX ~=~ \calX_0 ~\unrhd~ \calX_1 ~\unrhd~ \cdots ~\unrhd~ \calX_i ~\unrhd~ \cdots ~\unrhd~ \calX_n ~=~ \calY \quad (1 \leqslant i \leqslant n).

The quotients calF_i = calX_i / calX_i-1 are the factors of the series.

A factor calF_i is central if calX_i-1 ⊴ calX and calF_i is a subcrossed module of the centre of calX / calX_i-1.

A series is central if all its factors are central.

calX is soluble if it has a series all of whose factors are abelian.

calX is nilpotent is it has a series all of whose factors are central factors of calX.

The lower central series of calX is the sequence (see [Nor87], p.77):

\calX ~=~ \Gamma_1(\calX) ~\unrhd~ \Gamma_2(\calX) ~\unrhd~ \cdots \qquad \mbox{where} \qquad \Gamma_j(\calX) ~=~ [ \Gamma_{j-1}(\calX), \calX].

If calX is nilpotent, then its lower central series is its most rapidly descending central series.

The least integer c such that Γ_c+1(calX) is the trivial crossed module is the nilpotency class of calX.

    gap> lcs := LowerCentralSeries( X24 );;
    gap> List( lcs, g -> IdGroup(g) );
    [ [ [ 24, 6 ], [ 48, 38 ] ], [ [ 12, 2 ], [ 6, 2 ] ], [ [ 6, 2 ], [ 3, 1 ] ],
      [ [ 3, 1 ], [ 3, 1 ] ] ]
    gap> IsNilpotent2DimensionalGroup( X24 );
    false
    gap> NilpotencyClassOf2DimensionalGroup( X24 );
    0

##### 4.1-11 AllXMods

`‣ AllXMods`( args ) | ( function )

The global function `AllXMods` may be called in three ways: as `AllXMods(S,R)` to compute all crossed modules with chosen source and range groups; as `AllXMods([n,m])` to compute all crossed modules with a given size; or as `AllXMods(ord)` to compute all crossed modules whose associated cat1-groups have a given size `ord`.

In the example we see that there are 4 crossed modules (C_6 -> S_3); forming a subset of the 17 crossed modules with size `[6,6]`; and that these form a subset of the 205 crossed modules whose cat1-group has size 36. There are 40 precrossed modules with size `[6,6]`.

    gap> xc6s3 := AllXMods( SmallGroup(6,2), SmallGroup(6,1) );;
    gap> Length( xc6s3 );
    4
    gap> x66 := AllXMods( [6,6] );;
    gap> Length( x66 );
    17
    gap> x36 := AllXMods( 36 );;
    gap> Length( x36 );
    205
    gap> size36 := List( x36, x -> [ Size(Source(x)), Size(Range(x)) ] );;
    gap> Collected( size36 );
    [ [ [ 1, 36 ], 14 ], [ [ 2, 18 ], 7 ], [ [ 3, 12 ], 21 ], [ [ 4, 9 ], 14 ],
      [ [ 6, 6 ], 17 ], [ [ 9, 4 ], 102 ], [ [ 12, 3 ], 8 ], [ [ 18, 2 ], 18 ],
      [ [ 36, 1 ], 4 ] ]

##### 4.1-12 IsomorphismXMods

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

`‣ AllXModsUpToIsomorphism`( list ) | ( operation )

The function `IsomorphismXMods` computes an isomorphism μ : calX_1 -> calX_2, provided one exists, or else returns `fail`. In the example below we see that the 17 crossed modules of size `[6,6]` in `x66` (see the previous subsection) fall into 9 isomorphism classes.

The function `AllXModsUpToIsomorphism` takes a list of crossed modules and partitions them into isomorphism classes.

    gap> IsomorphismXMods( x66[1], x66[2] );
    [[Group( [ f1, f2 ] )->Group( [ f1, f2 ] )] => [Group( [ f1, f2 ] )->Group(
    [ f1, f2 ] )]]
    gap> iso66 := AllXModsUpToIsomorphism( x66 );;  Length( iso66 );
    9

#### 4.2 Isoclinism for groups

##### 4.2-1 Isoclinism

`‣ Isoclinism`( G, H ) | ( operation )

`‣ AreIsoclinicDomains`( G, H ) | ( operation )

Let G,H be groups with central quotients Q(G) and Q(H) and derived subgroups [G,G] and [H,H] respectively. Let c_G : G/Z(G) × G/Z(G) -> [G,G] and c_H : H/Z(H) × H/Z(H) -> [H,H] be the two commutator maps. An isoclinism G ∼ H is a pair of isomorphisms (η,ξ) where η : G/Z(G) -> H/Z(H) and ξ : [G,G] -> [H,H] such that c_G * ξ = (η × η) * c_H. Isoclinism is an equivalence relation, and all abelian groups are isoclinic to the trivial group.

    gap> G := SmallGroup( 64, 6 );;  StructureDescription( G );
    "(C8 x C4) : C2"
    gap> QG := CentralQuotient( G );;  IdGroup( QG );
    [ [ 64, 6 ], [ 8, 3 ] ]
    gap> H := SmallGroup( 32, 41 );;  StructureDescription( H );
    "C2 x Q16"
    gap> QH := CentralQuotient( H );;  IdGroup( QH );
    [ [ 32, 41 ], [ 8, 3 ] ]
    gap> Isoclinism( G, H );
    [ [ f1, f2, f3 ] -> [ f1, f2*f3, f3 ], [ f3, f5 ] -> [ f4*f5, f5 ] ]
    gap> K := SmallGroup( 32, 43 );;  StructureDescription( K );
    "(C2 x D8) : C2"
    gap> QK := CentralQuotient( K );;  IdGroup( QK );
    [ [ 32, 43 ], [ 16, 11 ] ]
    gap> AreIsoclinicDomains( G, K );
    false

##### 4.2-2 IsStemDomain

`‣ IsStemDomain`( G ) | ( property )

`‣ IsoclinicStemDomain`( G ) | ( attribute )

`‣ AllStemGroupIds`( n ) | ( operation )

`‣ AllStemGroupFamilies`( n ) | ( operation )

A group G is a stem group if Z(G) ≤ [G,G]. Every group is isoclinic to a stem group, but distinct stem groups may be isoclinic. For example, groups D_8, Q_8 are two isoclinic stem groups.

The function `IsoclinicStemDomain` returns a stem group isoclinic to G.

The function `AllStemGroupIds` returns the `IdGroup` list of the stem groups of a specified size, while `AllStemGroupFamilies` splits this list into isoclinism classes.

    gap> DerivedSubgroup(G);
    Group([ f3, f5 ])
    gap> IsStemDomain( G );
    false
    gap> IsoclinicStemDomain( G );
    <pc group of size 16 with 4 generators>
    gap> AllStemGroupIds( 32 );
    [ [ 32, 6 ], [ 32, 7 ], [ 32, 8 ], [ 32, 18 ], [ 32, 19 ], [ 32, 20 ],
      [ 32, 27 ], [ 32, 28 ], [ 32, 29 ], [ 32, 30 ], [ 32, 31 ], [ 32, 32 ],
      [ 32, 33 ], [ 32, 34 ], [ 32, 35 ], [ 32, 43 ], [ 32, 44 ], [ 32, 49 ],
      [ 32, 50 ] ]
    gap> AllStemGroupFamilies( 32 );
    [ [ [ 32, 6 ], [ 32, 7 ], [ 32, 8 ] ], [ [ 32, 18 ], [ 32, 19 ], [ 32, 20 ] ],
      [ [ 32, 27 ], [ 32, 28 ], [ 32, 29 ], [ 32, 30 ], [ 32, 31 ], [ 32, 32 ],
          [ 32, 33 ], [ 32, 34 ], [ 32, 35 ] ], [ [ 32, 43 ], [ 32, 44 ] ],
      [ [ 32, 49 ], [ 32, 50 ] ] ]

##### 4.2-3 IsoclinicRank

`‣ IsoclinicRank`( G ) | ( attribute )

`‣ IsoclinicMiddleLength`( G ) | ( attribute )

Let G be a finite p-group. Then log_p |[G,G] / (Z(G) ∩ [G,G])| is called the middle length of G. Also log_p |Z(G) ∩ [G,G]| + log_p |G/Z(G)| is called the rank of G. These invariants appear in the tables of isoclinism families of groups of order 128 in [JNO90].

    gap> IsoclinicMiddleLength( G );
    1
    gap> IsoclinicRank( G );
    4

#### 4.3 Isoclinism for crossed modules

##### 4.3-1 Isoclinism

`‣ Isoclinism`( X0, Y0 ) | ( operation )

`‣ AreIsoclinicDomains`( X0, Y0 ) | ( operation )

Let calX,calY be crossed modules with central quotients Q(calX) and Q(calY), and derived subcrossed modules [calX,calX] and [calY,calY] respectively. Let c_calX : Q(calX) × Q(calX) -> [calX,calX] and c_calY : Q(calY) × Q(calY) -> [calY,calY] be the two commutator maps. An isoclinism calX ∼ calY is a pair of bijective morphisms (η,ξ) where η : Q(calX) -> Q(calY) and ξ : [calX,calX] -> [calY,calY] such that c_calX * ξ = (η × η) * c_calY. Isoclinism is an equivalence relation, and all abelian crossed modules are isoclinic to the trivial crossed module.

    gap> C8 := Cat1Group( 16, 8, 1 );;
    gap> X8 := XMod(C8);  IdGroup( X8 );
    [Group( [ f1*f2*f3, f3, f4 ] )->Group( [ f2, f2 ] )]
    [ [ 8, 1 ], [ 2, 1 ] ]
    gap> C9 := Cat1Group( 32, 9, 1 );
    [(C8 x C2) : C2=>Group( [ f2, f2 ] )]
    gap> X9 := XMod( C9 );  IdGroup( X9 );
    [Group( [ f1*f2*f3, f3, f4, f5 ] )->Group( [ f2, f2 ] )]
    [ [ 16, 5 ], [ 2, 1 ] ]
    gap> AreIsoclinicDomains( X8, X9 );
    true
    gap> ism89 := Isoclinism( X8, X9 );;
    gap> Display( ism89 );
    [ [[Group( [ f1, f2, <identity> of ... ] ) -> Group( [ f2, f2 ] )] => [Group(
        [ f1, f2, <identity> of ..., <identity> of ... ] ) -> Group(
        [ f2, f2 ] )]],
      [[Group( [ f3 ] ) -> Group( <identity> of ... )] => [Group(
        [ f3 ] ) -> Group( <identity> of ... )]] ]

##### 4.3-2 IsStemDomain

`‣ IsStemDomain`( X0 ) | ( property )

`‣ IsoclinicStemDomain`( X0 ) | ( attribute )

A crossed module calX is a stem crossed module if Z(calX) ≤ [calX,calX]. Every crossed module is isoclinic to a stem crossed module, but distinct stem crossed modules may be isoclinic.

A method for `IsoclinicStemDomain` has yet to be implemented.

    gap> IsStemDomain(X8);
    true
    gap> IsStemDomain(X9);
    false

##### 4.3-3 IsoclinicRank

`‣ IsoclinicRank`( X0 ) | ( attribute )

`‣ IsoclinicMiddleLength`( X0 ) | ( attribute )

The formulae in subsection 4.2-3 are applied to the crossed module.

    gap> IsoclinicMiddleLength(X8);
    [ 1, 0 ]
    gap> IsoclinicRank(X8);
    [ 3, 1 ]

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

generated by GAPDoc2HTML