GAP (XMod) - Chapter 7: Crossed squares and their morphisms

Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Bib | Ind

### 7. Crossed squares and their morphisms

Crossed squares were introduced by Guin-Wal\'ery and Loday (see, for example, [RJ87]) as fundamental crossed squares of commutative squares of spaces, but are also of purely algebraic interest. We denote by [n] the set 1,2,...,n. We use the n=2 version of the definition of crossed n-cube as given by Ellis and Steiner [GR87].

A crossed square mathcalR consists of the following:

- Groups R_J for each of the four subsets J subseteq [2];

- a commutative diagram of group homomorphisms:

  \[ \ddot{\partial}_1 : R_{[2]} \to R_{\{2\}}, \quad \ddot{\partial}_2 : R_{[2]} \to R_{\{1\}}, \quad \dot{\partial}_1 : R_{\{1\}} \to R_{\emptyset}, \quad \dot{\partial}_2 : R_{\{2\}} \to R_{\emptyset}; \]

- actions of R_emptyset on R_1}, R_2} and R_[2] which determine actions of R_1} on R_2} and R_[2] via dotpartial_1 and actions of R_2} on R_1} and R_[2] via dotpartial_2~;

- a function ~ boxtimes : R_1} times R_2} -> R_[2]~.

The following axioms must be satisfied for all l in R_[2],; m,m_1,m_2 in R_1},; n,n_1,n_2 in R_2},; p in R_emptyset~:

- the homomorphisms ddotpartial_1, ddotpartial_2 preserve the action of R_emptyset~;

- each of

  \[ \ddot{\mathcal{R}}_1 = (\ddot{\partial}_1 : R_{[2]} \to R_{\{2\}}),~ \ddot{\mathcal{R}}_2 = (\ddot{\partial}_2 : R_{[2]} \to R_{\{1\}}), ~ \dot{\mathcal{R}}_1 = (\dot{\partial}_1 : R_{\{1\}} \to R_{\emptyset}),~ \dot{\mathcal{R}}_2 = (\dot{\partial}_2 : R_{\{2\}} \to R_{\emptyset}), \]

  and the diagonal

  \[ \mathcal{R}_{12} = (\partial_{12} := \dot{\partial}_1\ddot{\partial}_2 = \dot{\partial}_2\ddot{\partial}_1 : R_{[2]} \to R_{\emptyset}) \]

  are crossed modules (with actions via R_emptyset);

- boxtimes is a \emph{crossed pairing}:

  - (m_1m_2 boxtimes n);=;(m_1 boxtimes n)^m_2;(m_2 boxtimes n)~,

  - (m boxtimes n_1n_2) ;=; (m boxtimes n_2);(m boxtimes n_1)^n_2~,

  - (m boxtimes n)^p ;=; (m^p boxtimes n^p)~;

- ddotpartial_1 (m boxtimes n) ;=; (n^-1)^m;n \quad \mbox{and} \quad ddotpartial_2 (m boxtimes n) ;=; m^-1;m^n~,

- (m boxtimes ddotpartial_1 l) ;=; (l^-1)^m;l \quad \mbox{and} \quad (ddotpartial_2 l boxtimes n) ;=; l^-1;l^n~.

Note that the actions of R_1} on R_2} and R_2} on R_1} via R_emptyset are compatible since

\[ {m_1}^{(n^m)} \;=\; {m_1}^{\dot{\partial}_2(n^m)} \;=\; {m_1}^{m^{-1}(\dot{\partial}_2 n)m} \;=\; (({m_1}^{m^{-1}})^n)^m~. \]

#### 7.1 Constructions for crossed squares

Analogously to the data structure used for crossed modules, crossed squares are implemented as `3d-objects`. When times allows, cat2-groups will also be implemented, with conversion between the two types of structure. Some standard constructions of crossed squares are listed below. At present, a limited number of constructions are implemented. Morphisms of crossed squares have also been implemented, though there is a lot still to do.

##### 7.1-1 XSq

`> XSq`( args ) | ( function )

`> XSqByNormalSubgroups`( P, N, M, L ) | ( operation )

`> ActorXSq`( X0 ) | ( operation )

`> Transpose3dObject`( S0 ) | ( attribute )

`> Name`( S0 ) | ( attribute )

Here are some standard examples of crossed squares.

- If M, N are normal subgroups of a group P, and L = M cap N, then the four inclusions, L -> N,~ L -> M,~ M -> P,~ N -> P, together with the actions of P on M, N and L given by conjugation, and the crossed pairing

  \[ \boxtimes \;:\; M \times N \to M\cap N, \quad (m,n) \mapsto [m,n] \,=\, m^{-1}n^{-1}mn \,=\,(n^{-1})^mn \,=\, m^{-1}m^n \]

  is a crossed square. This construction is implemented as `XSqByNormalSubgroups(P,N,M,L);`.

- The actor mathcalA(mathcalX_0) of a crossed module mathcalX_0 has been described in Chapter 5. The crossed pairing is given by

  \[ \boxtimes \;:\; R \times W \,\to\, S, \quad (r,\chi) \,\mapsto\, \chi r~. \]

  This is implemented as `ActorXSq( X0 );`.

- The transpose of mathcalR is the crossed square tildemathcalR} obtained by interchanging R_1} with R_2}, ddotpartial_1 with ddotpartial_2, and dotpartial_1 with dotpartial_2. The crossed pairing is given by

  \[ \tilde{\boxtimes} \;:\; R_{\{2\}} \times R_{\{1\}} \to R_{[2]}, \quad (n,m) \;\mapsto\; n\,\tilde{\boxtimes}\,m := (m \boxtimes n)^{-1}~. \]

The following constructions will be implemented in the next release.

- If M, N are ordinary P-modules and A is an arbitrary abelian group on which P acts trivially, then there is a crossed square with sides

  \[ 0 : A \to N,\quad 0 : A \to M,\quad 0 : M \to P,\quad 0 : N \to P. \]

- For a group L, the automorphism crossed module rm Act L = (iota : L -> rm Aut L) splits to form the square with (iota_1 : L -> rm Inn L) on two sides, and (iota_2 : rm Inn L -> rm Aut L) on the other two sides, where iota_1 maps l in L to the inner automorphism beta_l : L -> L,; l^prime -> l^-1l^primel, and $\iota_2$ is the inclusion of rm Inn L in rm Aut L. The actions are standard, and the crossed pairing is

  \[ \boxtimes \;:\; {\rm Inn}\ L \times {\rm Inn}\ L \to L, \quad (\beta_l, \beta_{l^{\prime}}) \;\mapsto\; [l, l^{\prime}]~. \]

    gap> c := (11,12,13,14,15,16);;
    gap> d := (12,16)(13,15);;
    gap> cd := c*d;;
    gap> d12 := Group( [ c, d ] );;
    gap> s3a := Subgroup( d12, [ c^2, d ] );;
    gap> s3b := Subgroup( d12, [ c^2, cd ] );;
    gap> c3 := Subgroup( d12, [ c^2 ] );;
    gap> SetName( d12, "d12");  SetName( s3a, "s3a" );
    gap> SetName( s3b, "s3b" );  SetName( c3, "c3" );
    gap> XSconj := XSqByNormalSubgroups( d12, s3b, s3a, c3 );
    [  c3 -> s3b ]
    [  |      |  ]
    [ s3a -> d12 ]
    gap> Name( XSconj );
    "[c3->s3b,s3a->d12]"
    gap> XStrans := Transpose3dObject( XSconj );
    [  c3 -> s3a ]
    [  |      |  ]
    [ s3b -> d12 ]
    gap> X12 := XModByNormalSubgroup( d12, s3a );
    [s3a->d12]
    gap> XSact := ActorXSq( X12 );
    crossed square with:
          up = Whitehead[s3a->d12]
        left = [s3a->d12]
       right = Actor[s3a->d12]
        down = Norrie[s3a->d12]

##### 7.1-2 IsXSq

`> IsXSq`( obj ) | ( property )

`> IsPerm3dObject`( obj ) | ( property )

`> Is3dObject`( obj ) | ( property )

`> IsPerm3dObject`( obj ) | ( property )

`> IsPc3dObject`( obj ) | ( property )

`> IsFp3dObject`( obj ) | ( property )

`> IsPreXSq`( obj ) | ( property )

These are the basic properties for 3dobjects, and crossed squares in particular.

##### 7.1-3 Up2dObject

`> Up2dObject`( XS ) | ( attribute )

`> Left2dObject`( XS ) | ( attribute )

`> Down2dObject`( XS ) | ( attribute )

`> Right2dObject`( XS ) | ( attribute )

`> DiagonalAction`( XS ) | ( attribute )

`> XPair`( XS ) | ( attribute )

`> ImageElmXPair`( XS, pair ) | ( operation )

In this implementation the attributes used in the construction of a crossed square `XS` are the four crossed modules (2d-objects) on the sides of the square; the diagonal action of P on L, and the crossed pairing.

The GAP development team have suggested that crossed pairings should be implemented as a special case of `BinaryMappings` -- a structure which does not yet exist in GAP. As a temporary measure, crossed pairings have been implemented using `Mapping2ArgumentsByFunction`.

    gap> Up2dObject( XSconj );
    [c3->s3b]
    gap> Right2dObject( XSact );
    Actor[s3a->d12]
    gap> xpconj := XPair( XSconj );;
    gap> ImageElmXPair( xpconj, [ (1,6)(2,5)(3,4), (2,6)(3,5) ] );
    (1,3,5)(2,4,6)
    gap> diag := DiagonalAction( XSact );
    [ (2,3)(6,8)(7,9), (1,2)(4,6)(5,7) ] ->
    [ [ (11,13,15)(12,14,16), (12,16)(13,15) ] ->
        [ (11,15,13)(12,16,14), (12,16)(13,15) ],
      [ (11,13,15)(12,14,16), (12,16)(13,15) ] ->
        [ (11,15,13)(12,16,14), (11,13)(14,16) ] ]

#### 7.2 Morphisms of crossed squares

This section describes an initial implementation of morphisms of (pre-)crossed squares.

##### 7.2-1 Source

`> Source`( map ) | ( attribute )

`> Range`( map ) | ( attribute )

`> Up2dMorphism`( map ) | ( attribute )

`> Left2dMorphism`( map ) | ( attribute )

`> Down2dMorphism`( map ) | ( attribute )

`> Right2dMorphism`( map ) | ( attribute )

Morphisms of `3dObjects` are implemented as `3dMappings`. These have a pair of 3d-objects as source and range, together with four 2d-morphisms mapping between the four pairs of crossed modules on the four sides of the squares. These functions return `fail` when invalid data is supplied.

##### 7.2-2 IsXSqMorphism

`> IsXSqMorphism`( map ) | ( property )

`> IsPreXSqMorphism`( map ) | ( property )

`> IsBijective`( mor ) | ( property )

`> IsAutomorphism3dObject`( mor ) | ( property )

A morphism `mor` between two pre-crossed squares mathcalR_1 and mathcalR_2 consists of four crossed module morphisms `Up2dMorphism( mor )`, mapping the `Up2dObject` of mathcalR_1 to that of mathcalR_2, `Left2dMorphism( mor )`, `Down2dMorphism( mor )` and `Right2dMorphism( mor )`. These four morphisms are required to commute with the four boundary maps and to preserve the rest of the structure. The current version of `IsXSqMorphism` does not perform all the required checks.

    gap> ad12 := GroupHomomorphismByImages( d12, d12, [c,d], [c,d^c] );;
    gap> as3a := GroupHomomorphismByImages( s3a, s3a, [c^2,d], [c^2,d^c] );;
    gap> as3b := GroupHomomorphismByImages( s3b, s3b, [c^2,cd], [c^2,cd^c] );;
    gap> idc3 := IdentityMapping( c3 );;
    gap> upconj := Up2dObject( XSconj );;
    gap> leftconj := Left2dObject( XSconj );;
    gap> downconj := Down2dObject( XSconj );;
    gap> rightconj := Right2dObject( XSconj );;
    gap> up := XModMorphismByHoms( upconj, upconj, idc3, as3b );
    [[c3->s3b] => [c3->s3b]]
    gap> left := XModMorphismByHoms( leftconj, leftconj, idc3, as3a );
    [[c3->s3a] => [c3->s3a]]
    gap> down := XModMorphismByHoms( downconj, downconj, as3a, ad12 );
    [[s3a->d12] => [s3a->d12]]
    gap> right := XModMorphismByHoms( rightconj, rightconj, as3b, ad12 );
    [[s3b->d12] => [s3b->d12]]
    gap> autoconj := XSqMorphism( XSconj, XSconj, up, left, down, right );;
    gap> ord := Order( autoconj );;
    gap> Display( autoconj );
    Morphism of crossed squares :-
    :    Source = [c3->s3b,s3a->d12]
    :     Range = [c3->s3b,s3a->d12]
    :     order = 3
    :    up-left: [ [ (11,13,15)(12,14,16) ], [ (11,13,15)(12,14,16) ] ]
    :   up-right: [ [ (11,13,15)(12,14,16), (11,16)(12,15)(13,14) ],
      [ (11,13,15)(12,14,16), (11,12)(13,16)(14,15) ] ]
    :  down-left: [ [ (11,13,15)(12,14,16), (12,16)(13,15) ],
      [ (11,13,15)(12,14,16), (11,13)(14,16) ] ]
    : down-right: [ [ (11,12,13,14,15,16), (12,16)(13,15) ],
      [ (11,12,13,14,15,16), (11,13)(14,16) ] ]
    gap> KnownPropertiesOfObject( autoconj );
    [ "IsTotal", "IsSingleValued", "IsInjective", "IsSurjective", "Is3dMapping",
      "IsPreXSqMorphism", "IsXSqMorphism", "IsEndomorphism3dObject" ]
    gap> IsAutomorphism3dObject( autoconj );
    true

Top of Book | Previous Chapter | Next Chapter

Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Bib | Ind

generated by GAPDoc2HTML