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  mathcalX_2  =  (∂_2 : S_2 -> R_2) is a normal sub-precrossed module of
  mathcalX_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.
  
    Example  
    
    gap> d24 := DihedralGroup(24);;  SetName( d24, "d24" );
    gap> X24 := XModByAutomorphismGroup( d24 );;  Size(X24);
    [ 24, 48 ]
    gap> nsx := NormalSubXMods( X24 );; 
    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 ); 
    [[d24->PAut(d24)] => [..]]
    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.
  
    Example  
    
    gap> pos2 := Position( ids, [ [24,6], [12,4] ] );;
    gap> Xn2 := nsx[pos2]; 
    [d24->Group( [ f1*f3, f2, f5 ] )]
    gap> pos3 := Position( ids, [ [12,2], [24,5] ] );;
    gap> Xn3 := nsx[pos3]; 
    [Group( [ f2, f3, f4 ] )->Group( [ f1, f2, f4, f5 ] )]
    gap> Xn23 := IntersectionSubXMods( X24, Xn2, Xn3 );
    [Group( [ f2, f3, f4 ] )->Group( [ f2, f5, f2^2, f2*f5, f2^2*f5 ] )]
    gap> [ Size(Xn2), Size(Xn3), Size(Xn23) ];
    [ [ 24, 12 ], [ 12, 24 ], [ 12, 6 ] ]
    
  
  
  4.1-3 Displacement
  
  Displacement( alpha, r, s )  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 mathcalX = (∂ : S
  ->  R)  is  a pre-crossed module, the first crossed module axiom requires ∂⟨
  r,s  ⟩ = [r,∂ s]. For a given action α 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  DisplacementSubgroup  of  mathcalX  is the subgroup Disp(mathcalX) of S
  generated  by  these  displacements.  The  identities  imply  ⟨  r,s ⟩^t = ⟨
  r,st^r^-1} ⟩ ⟨ r^-1,t ⟩, so Disp(mathcalX) is normal in S.
  
    Example  
    
    gap> pos4 := Position( ids, [ [6,2], [24,14] ] );;
    gap> Xn4 := nsx[pos4];; 
    gap> Sn4 := Source(Xn4);; 
    gap> Rn4 := Range(Xn4);; 
    gap> r := Rn4.1;;  s := Sn4.1;; 
    gap> d := Displacement( XModAction(Xn4), r, s );
    f4
    gap> bn4 := Boundary( Xn4 );;
    gap> Image( bn4, d ) = Comm( r, Image( bn4, s ) );  
    true
    gap> DisplacementSubgroup( Xn4 );
    Group([ f4 ])
    
  
  
  4.1-4 CommutatorSubXMod
  
  CommutatorSubXMod( X, X1, X2 )  operation
  CrossActionSubgroup( X, X1, X2 )  operation
  
  When  mathcalX_1 = (N -> Q), mathcalX_2 = (M -> P) are two normal subcrossed
  modules  of  mathcalX  = (∂ : 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
  [mathcalX_1,mathcalX_2]  has this subgroup as source and [P,Q] as range, and
  is normal in mathcalX.
  
    Example  
    
    gap> CrossActionSubgroup( X24, Xn2, Xn3 );
    Group([ f2 ])
    gap> Cn23 := CommutatorSubXMod( X24, Xn2, Xn3 );
    [Group( [ f2 ] )->Group( [ f2, f5 ] )]
    gap> Size(Cn23);
    [ 12, 6 ]
    gap> Xn23 = Cn23;
    true
    
  
  
  4.1-5 DerivedSubXMod
  
  DerivedSubXMod( X0 )  attribute
  
  The   DerivedSubXMod   of   mathcalX   is   the   normal  subcrossed  module
  [mathcalX,mathcalX]  =  (∂'  :  Disp(mathcalX)  ->  [R,R])  where  ∂' is the
  restriction of ∂ (see page 66 of Norrie's thesis [Nor87]).
  
    Example  
    
    gap> DXn4 := DerivedSubXMod( Xn4 );  
    [Group( [ f4 ] )->Group( [ f2 ] )]
    
  
  
  4.1-6 FixedPointSubgroupXMod
  
  FixedPointSubgroupXMod( X0, T, Q )  operation
  StabilizerSubgroupXMod( X0, T, Q )  operation
  
  The  FixedPointSubgroupXMod(X,T,Q) for mathcalX=(∂ : S -> R) is the subgroup
  Fix(mathcalX,T,Q)  of elements t ∈ T leqslant S individually fixed under the
  action of Q leqslant R.
  
  The    StabilizerSubgroupXMod(X,T,Q)    for   mathcalX   is   the   subgroup
  Stab(mathcalX,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]).
  
    Example  
    
    gap> fix := FixedPointSubgroupXMod( Xn4, Sn4, Rn4 );
    Group([ f3*f4 ])
    gap> stab := StabilizerSubgroupXMod( Xn4, Sn4, Rn4 );
    Group([ f5, f2*f3 ])
    
  
  
  4.1-7 CentreXMod
  
  CentreXMod( X0 )  attribute
  Centralizer( X, Y )  operation
  Normalizer( X, Y )  operation
  
  The  centre  Z(mathcalX)  of mathcalX = (∂ : S -> R) has as source the fixed
  point  subgroup  Fix(mathcalX,S,R).  The  range  is  the intersection of the
  centre Z(R) with the stabilizer subgroup.
  
  When  mathcalY = (T -> Q) is a subcrossed module of mathcalX = (∂ : S -> R),
  the  centralizer  C_mathcalX}(mathcalY)  of mathcalY has as source the fixed
  point  subgroup  Fix(mathcalX,S,Q).  The  range  is  the intersection of the
  centralizer C_R(Q) with Stab(mathcalX,T,R).
  
  The  normalizer N_mathcalX}(mathcalY) of mathcalY has as source the subgroup
  of S consisting of the displacements ⟨ s,q ⟩ which lie in S.
  
    Example  
    
    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 (see 2.1).
  
  Similarly,  the central quotient of a crossed module mathcalX is the crossed
  square (mathcalX ⇒ mathcalX/Z(mathcalX) (see section 8.2).
  
    Example  
    
    gap> Q24 := CentralQuotient( d24 );  Size( Q24 );                     
    [d24->Group( [ f1, f2, f3 ] )]
    [ 24, 12 ]
    
  
  
  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.
  
    Example  
    
    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  mathcalY be a subcrossed module of mathcalX. A  series of length n from
  mathcalX to mathcalY has the form
  
  
  \mathcal{X}   ~=~   \mathcal{X}_0  ~\unrhd~  \mathcal{X}_1  ~\unrhd~  \cdots
  ~\unrhd~   \mathcal{X}_i   ~\unrhd~   \cdots   ~\unrhd~   \mathcal{X}_n  ~=~
  \mathcal{Y} \quad (1 \leqslant i \leqslant n).
  
  
  
  The  quotients mathcalF_i = mathcalX_i / mathcalX_i-1 are the factors of the
  series.
  
  A  factor mathcalF_i is central if mathcalX_i-1 ⊴ mathcalX and mathcalF_i is
  a subcrossed module of the centre of mathcalX / mathcalX_i-1.
  
  A series is central if all its factors are central.
  
  mathcalX is soluble if it has a series all of whose factors are abelian.
  
  mathcalX  is  nilpotent  is it has a series all of whose factors are central
  factors of mathcalX.
  
  The lower central series of mathcalX is the sequence (see [Nor87], p.77):
  
  
  \mathcal{X}   ~=~   \Gamma_1(\mathcal{X})   ~\unrhd~   \Gamma_2(\mathcal{X})
  ~\unrhd~  \cdots  \qquad  \mbox{where}  \qquad  \Gamma_j(\mathcal{X})  ~=~ [
  \Gamma_{j-1}(\mathcal{X}), \mathcal{X}].
  
  
  
  If  mathcalX is nilpotent, then its lower central series is its most rapidly
  descending central series.
  
  The  least integer c such that Γ_c+1(mathcalX) is the trivial crossed module
  is the nilpotency class of mathcalX.
  
    Example  
    
    gap> LowerCentralSeries(X24);      
    [ [d24->PAut(d24)], [Group( [ f2 ] )->Group( [ f2, f5 ] )], 
      [Group( [ f3*f4^2 ] )->Group( [ f2 ] )], [Group( [ f4 ] )->Group( [ f2 ] )] 
     ]
    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].
  
    Example  
    
    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 μ : mathcalX_1 ->
  mathcalX_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.
  
    Example  
    
    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.
  
    Example  
    
    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.
  
    Example  
    
    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].
  
    Example  
    
    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  mathcalX,mathcalY be crossed modules with central quotients Q(mathcalX)
  and  Q(mathcalY),  and  derived  subcrossed  modules [mathcalX,mathcalX] and
  [mathcalY,mathcalY] respectively. Let c_mathcalX : Q(mathcalX) × Q(mathcalX)
  ->  [mathcalX,mathcalX]  and  c_mathcalY  :  Q(mathcalY)  ×  Q(mathcalY)  ->
  [mathcalY,mathcalY]  be  the  two  commutator maps. An isoclinism mathcalX ∼
  mathcalY  is  a  pair  of bijective morphisms (η,ξ) where η : Q(mathcalX) ->
  Q(mathcalY)  and  ξ  :  [mathcalX,mathcalX] -> [mathcalY,mathcalY] such that
  c_mathcalX  *  ξ  =  (η  ×  η)  *  c_mathcalY.  Isoclinism is an equivalence
  relation,  and  all  abelian  crossed  modules  are isoclinic to the trivial
  crossed module.
  
    Example  
    
    gap> C8 := Cat1(16,8,1);;
    gap> X8 := XMod(C8);  IdGroup( X8 );
    [Group( [ f1*f2*f3, f3, f4 ] )->Group( [ f2, f2 ] )]
    [ [ 8, 1 ], [ 2, 1 ] ]
    gap> C9 := Cat1(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 ] )->Group( [ f2 ] )] => [Group( [ f1 ] )->Group( [ f2 ] )]], 
      [[Group( [ f3 ] )->Group( <identity> of ... )] => [Group( 
        [ f3 ] )->Group( <identity> of ... )]] ]
    
  
  
  4.3-2 IsStemDomain
  
  IsStemDomain( X0 )  property
  IsoclinicStemDomain( X0 )  property
  
  A  crossed  module  mathcalX  is  a  stem  crossed  module  if Z(mathcalX) ≤
  [mathcalX,mathcalX].  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.
  
    Example  
    
    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.
  
    Example  
    
    gap> IsoclinicMiddleLength(X8);
    [ 1, 0 ]
    gap> IsoclinicRank(X8);        
    [ 3, 1 ]