GAP (XMod) - Chapter 8: Crossed squares and Cat^2-groups

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

[MathJax on]

8 Crossed squares and Cat^2-groups
8.1 Definition of a crossed square and a crossed n-cube of groups
8.2 Constructions for crossed squares
8.2-1 CrossedSquareByNormalSubgroups
8.2-2 CrossedSquareByNormalSubXMod
8.2-3 ActorCrossedSquare
8.2-4 CrossedSquareByAutomorphismGroup
8.2-5 CrossedSquareByPullback
8.2-6 CrossedSquareByXModSplitting
8.2-7 CrossedSquare
8.2-8 Transpose3DimensionalGroup
8.2-9 CentralQuotient
8.2-10 IsCrossedSquare
8.2-11 Up2DimensionalGroup
8.2-12 ImageElmCrossedPairing
8.3 Morphisms of crossed squares
8.3-1 CrossedSquareMorphism
8.3-2 Source
8.3-3 IsCrossedSquareMorphism
8.3-4 InclusionMorphismHigherDimensionalDomains
8.4 Definitions and constructions for cat^2-groups and their morphisms
8.4-1 Cat2Group
8.4-2 Cat2GroupMorphism
8.4-3 Cat2GroupOfCrossedSquare
8.5 Definition and constructions for cat^n-groups and their morphisms

### 8 Crossed squares and Cat^2-groups

The term 3d-group refers to a set of equivalent categories of which the most common are the categories of crossed squares and cat^2-groups. A 3d-mapping is a function between two 3d-groups which preserves all the structure.

The material in this chapter should be considered experimental. A major overhaul took place in time for XMod version 2.73, with the names of a number of operations being changed.

#### 8.1 Definition of a crossed square and a crossed n-cube of groups

Crossed squares were introduced by Guin-Waléry and Loday (see, for example, [BL87]) 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 [ES87].

A crossed square mathcalS consists of the following:

- groups S_J for each of the four subsets J ⊆ [2] (we often find it convenient to write L = S_[2],~ M = S_{1},~ N = S_{2} and P = S_∅);

- a commutative diagram of group homomorphisms:

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

  (again we often write κ = ddot∂_1,~ λ = ddot∂_2,~ μ = dot∂_2 and ν = dot∂_1);

- actions of S_∅ on S_{1}, S_{2} and S_[2] which determine actions of S_{1} on S_{2} and S_[2] via dot∂_1 and actions of S_{2} on S_{1} and S_[2] via dot∂_2;

- a function ⊠ : S_{1} × S_{2} -> S_[2].

Here is a picture of the situation:

\vcenter{\xymatrix{ & & S_{[2]} \ar[rr]^{\ddot{\partial}_1} \ar[dd]_{\ddot{\partial}_2} && S_{\{2\}} \ar[dd]^{\dot{\partial}_2} && L \ar[rr]^{\kappa} \ar[dd]_{\lambda} && M \ar[dd]^{\mu} & \\ \mathcal{S} & = & && & = && \\ & & S_{\{1\}} \ar[rr]_{\dot{\partial}_1} && S_{\emptyset} && N \ar[rr]_{\nu} && P }}

The following axioms must be satisfied for all l ∈ L, m,m_1,m_2 ∈ M, n,n_1,n_2 ∈ N, p ∈ P.

- The homomorphisms κ, λ preserve the action of P.

- Each of the upper, left-hand, right-hand and lower sides of the square,

  \ddot{\mathcal{S}}_1 = (\kappa : L \to M), \quad \ddot{\mathcal{S}}_2 = (\lambda : L \to N), \quad \dot{\mathcal{S}}_2 = (\mu : M \to P), \quad \dot{\mathcal{S}}_1 = (\nu : N \to P),

  and the diagonal

  \mathcal{S}_{12} = (\partial_{12} := \mu \circ \kappa = \nu \circ \lambda : L \to P)

  are crossed modules (with actions via P).

  The first four of these are called the up, left, right and down crossed modules of mathcalS.

- ⊠ is a crossed pairing:

  - (n_1n_2 ⊠ m) = (n_1 ⊠ m)^n_2 (n_2 ⊠ m),

  - (n ⊠ m_1m_2) = (n ⊠ m_2) (n ⊠ m_1)^m_2,

  - (n ⊠ m)^p = (n^p ⊠ m^p).

- ddot∂_1 (n ⊠ m) = (m^-1)^n m quad mboxand quad ddot∂_2 (n ⊠ m) = n^-1 n^m.

- (n ⊠ ddot∂_1 l) = (l^-1)^n l quad mboxand quad (ddot∂_2 l ⊠ m) = l^-1 l^m.

Note that the actions of M on N and N on M via P are compatible since

{n_1}^{(m^n)} \;=\; {n_1}^{\dot{\partial}_2(m^n)} \;=\; {n_1}^{n^{-1}(\dot{\partial}_2 m)n} \;=\; (({n_1}^{n^{-1}})^m)^n.

(A precrossed square is a similar structure which satisfies some subset of these axioms. This notion needs to be clarified.)

Crossed squares are the k=2 case of a crossed k-cube of groups, defined as follows. (This is an attempt to translate Definition 2.1 in Ronnie Brown's Computing homotopy types using crossed n-cubes of groups into right actions -- but this definition is not yet completely understood!)

A crossed k-cube of groups consists of the following:

- groups S_A for every subset A ⊆ [k];

- a commutative diagram of group homomorphisms ∂_i : S_A -> S_A ∖ {i}, i ∈ [k]; with composites ∂_B : S_A -> S_A ∖ B, B ⊆ [k];

- actions of S_∅ on each S_A; and hence actions of S_B on S_A via ∂_B for each B ⊆ [k];

- functions ⊠_A,B : S_A × S_B -> S_A ∪ B, (A,B ⊆ [k]).

There is then a long list of axioms which must be satisfied.

#### 8.2 Constructions for crossed squares

Analogously to the data structure used for crossed modules, crossed squares are implemented as `3d-groups`. There are also experimental implementations of cat^2-groups, with conversion between the two types of structure. Some standard constructions of crossed squares are listed below. At present, a limited number of constructions is implemented. Morphisms of crossed squares have also been implemented, though there is still a lot to be done.

##### 8.2-1 CrossedSquareByNormalSubgroups

`‣ CrossedSquareByNormalSubgroups`( L, M, N, P ) | ( operation )

If L, M, N are normal subgroups of a group P, and [M,N] leqslant L leqslant M ∩ N, then the four inclusions L -> M,~ L -> N,~ M -> P,~ N -> P, together with the actions of P on M, N and L given by conjugation, form a crossed square with crossed pairing

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

This construction is implemented as `CrossedSquareByNormalSubgroups(L,M,N,P);` (note that the parent group come last).

    gap> d20 := DihedralGroup( IsPermGroup, 20 );;
    gap> gend20 := GeneratorsOfGroup( d20 );
    [ (1,2,3,4,5,6,7,8,9,10), (2,10)(3,9)(4,8)(5,7) ]
    gap> p1 := gend20[1];;  p2 := gend20[2];;  p12 := p1*p2;
    (1,10)(2,9)(3,8)(4,7)(5,6)
    gap> d10a := Subgroup( d20, [ p1^2, p2 ] );;
    gap> d10b := Subgroup( d20, [ p1^2, p12 ] );;
    gap> c5d := Subgroup( d20, [ p1^2 ] );;
    gap> SetName( d20, "d20" );  SetName( d10a, "d10a" );
    gap> SetName( d10b, "d10b" );  SetName( c5d, "c5d" );
    gap> XSconj := CrossedSquareByNormalSubgroups( c5d, d10a, d10b, d20 );
    [  c5d -> d10a ]
    [   |      |   ]
    [ d10b -> d20  ]

##### 8.2-2 CrossedSquareByNormalSubXMod

`‣ CrossedSquareByNormalSubXMod`( X0, X1 ) | ( operation )

If mathcalX_1 = (∂_1 : S_1 -> R_1) is a normal sub-crossed module of mathcalX_0 = (∂_0 : S_0 -> R_0) then the inclusion morphism gives a crossed square with crossed pairing

\boxtimes \;:\; R_1 \times S_0 \to S_1, \quad (r_1,s_0) \mapsto (s_0^{-1})^{r_1} s_0.

The example constructs the same crossed square as in the previous subsection.

    gap> X20 := XModByNormalSubgroup( d20, d10a );;
    gap> X10 := XModByNormalSubgroup( d10b, c5d );;
    gap> ok := IsNormalSub2DimensionalDomain( X20, X10 );
    true
    gap> XS20 := CrossedSquareByNormalSubXMod( X20, X10 );
    [  c5d -> d10a ]
    [   |      |   ]
    [ d10b -> d20  ]

##### 8.2-3 ActorCrossedSquare

`‣ ActorCrossedSquare`( X0 ) | ( operation )

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

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

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

    gap> XSact := ActorCrossedSquare( X20 );
    crossed square with:
          up = Whitehead[d10a->d20]
        left = [d10a->d20]
       right = Actor[d10a->d20]
        down = Norrie[d10a->d20]

##### 8.2-4 CrossedSquareByAutomorphismGroup

`‣ CrossedSquareByAutomorphismGroup`( G ) | ( operation )

For G a group let Inn(G) be its inner automorphism group and Aut(G) its full automorphism group. Then there is a crossed square with groups [G,Inn(G),Inn(G),Aut(G)] where the upper and left boundaries are the maps g ↦ ι_g, where ι_g is conjugation of G by g, and the right and down boundaries are inclusions. The crossed pairing is gived by ι_g ⊠ ι_h = [g,h].

    gap> AXS20 := CrossedSquareByAutomorphismGroup( d20 );
    [      d20 -> Inn(d20) ]
    [     |          |     ]
    [ Inn(d20) -> Aut(d20) ]

    gap> StructureDescription( AXS20 );
    [ "D20", "D10", "D10", "C2 x (C5 : C4)" ]

##### 8.2-5 CrossedSquareByPullback

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

If crossed modules mathcalX_1 = (ν : N -> P) and mathcalX_2 = (μ : M -> P) have a common range P, let L be the pullback of {ν,μ}. Then N acts on L by (n,m)^n' = (n^n',m^ν n'), and M acts on L by (n,m)^m' = (n^μ m', m^m'). So (π_1 : L -> N) and (π_2 : L -> M) are crossed modules, where π_1,π_2 are the two projections. The crossed pairing is given by:

\boxtimes \;:\; N \times M \to L, \quad (n,m) \mapsto (n^{-1}n^{\mu m}, (m^{-1})^{\nu n}m) .

The second example uses the central extension crossed module `X12=(D12->S3)` constructed in subsection (`XModByCentralExtension` (2.1-5)), with pullback group `D12xC2`.

    gap> dn := Down2DimensionalGroup( XSconj );;
    gap> rt := Right2DimensionalGroup( XSconj );;
    gap> XSP := CrossedSquareByPullback( dn, rt );
    gap> StructureDescription( XSP );
    [ "C5", "D10", "D10", "D20" ]
    gap> XS12 := CrossedSquareByPullback( X12, X12 );;
    gap> StructureDescription( XS12 );
    [ "C2 x C2 x S3", "D12", "D12", "S3" ]

##### 8.2-6 CrossedSquareByXModSplitting

`‣ CrossedSquareByXModSplitting`( X0 ) | ( attribute )

For mathcalX = (∂ : S -> R) let Q be the image of ∂. Then ∂ = ∂' ∘ ι where ∂' : S -> Q and ι is the inclusion of Q in R. The diagonal of the square is then the initial mathcalX, and the crossed pairing is given by commutators.

A particular case is when S is an R-module A and ∂ is the zero map.

\vcenter{\xymatrix{ & & S \ar[rr]^{\partial'} \ar[dd]_{\partial'} && Q \ar[dd]^{\iota} && A \ar[rr]^0 \ar[dd]_0 && 1 \ar[dd]^{\iota} & \\ & & && & && \\ & & Q \ar[rr]_{\iota} && R && 1 \ar[rr]_{\iota} && R }}

    gap> k4 := Group( (1,2), (3,4) );;
    gap> AX4 := XModByAutomorphismGroup( k4 );;
    gap> X4 := Image( IsomorphismPermObject( AX4 ) );;
    gap> XSS4 := CrossedSquareByXModSplitting( X4 );;
    gap> StructureDescription( XSS4 );
    [ "C2 x C2", "1", "1", "S3" ]
    gap> XSS20 := CrossedSquareByXModSplitting( X20 );;
    gap> up20 := Up2DimensionalGroup( XSS20 );;
    gap> Range( up20 ) = d10a;
    true
    gap> SetName( Range( up20 ), "d10a" );
    gap> Name( XSS20 );
    "[d10a->d10a,d10a->d20]"

##### 8.2-7 CrossedSquare

`‣ CrossedSquare`( args ) | ( function )

The function `CrossedSquare` may be used to call some of the constructions described in the previous subsections.

- `CrossedSquare(X0)` calls `CrossedSquareByXModSplitting`.

- `CrossedSquare(C0)` calls `CrossedSquareOfCat2Group`.

- `CrossedSquare(X0,X1)` calls `CrossedSquareByPullback` when there is a common range.

- `CrossedSquare(X0,X1)` calls `CrossedSquareByNormalXMod` when `X1` is normal in `X0` .

- `CrossedSquare(L,M,N,P)` calls `CrossedSquareByNormalSubgroups`.

    gap> diag := Diagonal2DimensionalGroup( AXS20 );
    [d20->Aut(d20)]
    gap> XSdiag := CrossedSquare( diag );;
    gap> StructureDescription( XSdiag );
    [ "D20", "D10", "D10", "C2 x (C5 : C4)" ]

##### 8.2-8 Transpose3DimensionalGroup

`‣ Transpose3DimensionalGroup`( S0 ) | ( attribute )

The transpose of a crossed square mathcalS is the crossed square tildemathcalS} obtained by interchanging M with N, κ with λ, and ν with μ. The crossed pairing is given by

\tilde{\boxtimes} \;:\; M \times N \to L, \quad (m,n) \;\mapsto\; m\,\tilde{\boxtimes}\,n := (n \boxtimes m)^{-1}~.

    gap> XStrans := Transpose3DimensionalGroup( XSconj );
    [  c5d -> d10b ]
    [   |      |   ]
    [ d10a -> d20  ]

##### 8.2-9 CentralQuotient

`‣ CentralQuotient`( X0 ) | ( attribute )

The central quotient of a crossed module mathcalX = (∂ : S -> R) is the crossed square where:

- the left crossed module is mathcalX;

- the right crossed module is the quotient mathcalX/Z(mathcalX) (see `CentreXMod` (4.1-7));

- the up and down homomorphisms are the natural homomorphisms onto the quotient groups;

- the crossed pairing ⊠ : (R × F) -> S, where F = Fix(mathcalX,S,R), is the displacement element ⊠(r,Fs) = ⟨ r,s ⟩ = (s^-1)^rsquad (see `Displacement` (4.1-3) and section 4.3).

This is the special case of an intended function `CrossedSquareByCentralExtension` which has not yet been implemented. In the example `Xn7` ⊴ `X24`, constructed in section 4.1.

    gap> pos7 := Position( ids, [ [12,2], [24,5] ] );;
    gap> Xn7 := nsx[pos7];;
    gap> IdGroup( Xn7 );
    [ [ 12, 2 ], [ 24, 5 ] ]
    gap> IdGroup( CentreXMod( Xn7 ) );
    [ [ 4, 1 ], [ 4, 1 ] ]
    gap> CQXn7 := CentralQuotient( Xn7 );;
    gap> StructureDescription( CQXn7 );
    [ "C12", "C3", "C4 x S3", "S3" ]

##### 8.2-10 IsCrossedSquare

`‣ IsCrossedSquare`( obj ) | ( property )

`‣ Is3dObject`( obj ) | ( property )

`‣ IsPerm3dObject`( obj ) | ( property )

`‣ IsPc3dObject`( obj ) | ( property )

`‣ IsFp3dObject`( obj ) | ( property )

`‣ IsPreCrossedSquare`( obj ) | ( property )

These are the basic properties for 3d-groups, and crossed squares in particular.

##### 8.2-11 Up2DimensionalGroup

`‣ Up2DimensionalGroup`( XS ) | ( attribute )

`‣ Left2DimensionalGroup`( XS ) | ( attribute )

`‣ Down2DimensionalGroup`( XS ) | ( attribute )

`‣ Right2DimensionalGroup`( XS ) | ( attribute )

`‣ DiagonalAction`( XS ) | ( attribute )

`‣ CrossedPairing`( XS ) | ( attribute )

`‣ Diagonal2DimensionalGroup`( XS ) | ( attribute )

`‣ Name`( S0 ) | ( method )

These are the basic attributes of a crossed square mathcalS. The six objects used in the construction of mathcalS are the four crossed modules (2d-groups) on the sides of the square (up; left; right and down); the diagonal action of P on L; and the crossed pairing {M,N} -> L. The diagonal crossed module (L -> P) is an additional attribute.

Crossed pairings have been implemented using an operation `Mapping2ArgumentsByFunction`. This encodes a map {M,N} -> L as a map M × N -> L.

    gap> Up2DimensionalGroup( XSconj );
    [c5d->d10a]
    gap> Right2DimensionalGroup( XSact );
    Actor[d10a->d20]
    gap> diact := DiagonalAction( XSact );;
    gap> ImageElm( diact, (1,4)(2,3)(6,9)(7,8) );
    ^(1,5,7,3)(2,8,6,10)
    gap> Diagonal2DimensionalGroup( XSconj );
    [c5d->d20]
    gap> Name( XSconj );
    "[c5d->d10a,d10b->d20]"

##### 8.2-12 ImageElmCrossedPairing

`‣ ImageElmCrossedPairing`( XS, pair ) | ( operation )

This operation returns the image when a crossed pairing {M,N} -> L is applied to the pair [m,n] with m ∈ M,~ n ∈ N.

    gap> xp := CrossedPairing( XSconj );;
    gap> ImageElmCrossedPairing( xp,
    >      [ (1,6)(2,5)(3,4)(7,10)(8,9), (1,5)(2,4)(6,9)(7,8) ] );
    (1,7,8,5,3)(2,9,10,6,4)

#### 8.3 Morphisms of crossed squares

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

##### 8.3-1 CrossedSquareMorphism

`‣ CrossedSquareMorphism`( args ) | ( function )

`‣ CrossedSquareMorphismByXModMorphisms`( src, rng, mors ) | ( operation )

`‣ CrossedSquareMorphismByGroupHomomorphisms`( src, rng, homs ) | ( operation )

`‣ PreCrossedSquareMorphismByPreXModMorphisms`( src, rng, mors ) | ( operation )

`‣ PreCrossedSquareMorphismByGroupHomomorphisms`( src, rng, homs ) | ( operation )

##### 8.3-2 Source

`‣ Source`( map ) | ( attribute )

`‣ Range`( map ) | ( attribute )

`‣ Up2DimensionalMorphism`( map ) | ( attribute )

`‣ Left2DimensionalMorphism`( map ) | ( attribute )

`‣ Down2DimensionalMorphism`( map ) | ( attribute )

`‣ Right2DimensionalMorphism`( map ) | ( attribute )

Morphisms of `3dObjects` are implemented as `3dMappings`. These have a pair of 3d-groups 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.

##### 8.3-3 IsCrossedSquareMorphism

`‣ IsCrossedSquareMorphism`( map ) | ( property )

`‣ IsPreCrossedSquareMorphism`( map ) | ( property )

`‣ IsBijective`( mor ) | ( method )

`‣ IsEndomorphism3dObject`( mor ) | ( property )

`‣ IsAutomorphism3dObject`( mor ) | ( property )

A morphism `mor` between two pre-crossed squares mathcalS_1 and mathcalS_2 consists of four crossed module morphisms `Up2DimensionalMorphism(mor)`, mapping the `Up2DimensionalGroup` of mathcalS_1 to that of mathcalS_2, `Left2DimensionalMorphism(mor)`, `Right2DimensionalMorphism(mor)` and `Down2DimensionalMorphism(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 `IsCrossedSquareMorphism` does not perform all the required checks.

    gap> ad20 := GroupHomomorphismByImages( d20, d20, [p1,p2], [p1,p2^p1] );;
    gap> ad10a := GroupHomomorphismByImages( d10a, d10a, [p1^2,p2], [p1^2,p2^p1] );;
    gap> ad10b := GroupHomomorphismByImages( d10b, d10b, [p1^2,p12], [p1^2,p12^p1] );;
    gap> idc5d := IdentityMapping( c5d );;
    gap> up := Up2DimensionalGroup( XSconj );;
    gap> lt := Left2DimensionalGroup( XSconj );;
    gap> rt := Right2DimensionalGroup( XSconj );;
    gap> dn := Down2DimensionalGroup( XSconj );;
    gap> mup := XModMorphismByGroupHomomorphisms( up, up, idc5d, ad10a );
    [[c5d->d10a] => [c5d->d10a]]
    gap> mlt := XModMorphismByGroupHomomorphisms( lt, lt, idc5d, ad10b );
    [[c5d->d10b] => [c5d->d10b]]
    gap> mrt := XModMorphismByGroupHomomorphisms( rt, rt, ad10a, ad20 );
    [[d10a->d20] => [d10a->d20]]
    gap> mdn := XModMorphismByGroupHomomorphisms( dn, dn, ad10b, ad20 );
    [[d10b->d20] => [d10b->d20]]
    gap> autoconj := CrossedSquareMorphism( XSconj, XSconj, [mup,mlt,mrt,mdn] );;
    gap> ord := Order( autoconj );;
    gap> Display( autoconj );
    Morphism of crossed squares :-
    : Source = [c5d->d10a,d10b->d20]
    : Range = [c5d->d10a,d10b->d20]
    :     order = 5
    :    up-left: [ [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10) ],
      [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10) ] ]
    :   up-right:
    [ [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 2,10)( 3, 9)( 4, 8)( 5, 7) ],
      [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1, 3)( 4,10)( 5, 9)( 6, 8) ] ]
    :  down-left:
    [ [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1,10)( 2, 9)( 3, 8)( 4, 7)( 5, 6) ],
      [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1, 2)( 3,10)( 4, 9)( 5, 8)( 6, 7) ] ]
    : down-right:
    [ [ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10), ( 2,10)( 3, 9)( 4, 8)( 5, 7) ],
      [ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10), ( 1, 3)( 4,10)( 5, 9)( 6, 8) ] ]
    gap> IsAutomorphismHigherDimensionalDomain( autoconj );
    true
    gap> KnownPropertiesOfObject( autoconj );
    [ "CanEasilyCompareElements", "CanEasilySortElements", "IsTotal",
      "IsSingleValued", "IsInjective", "IsSurjective",
      "IsPreCrossedSquareMorphism", "IsCrossedSquareMorphism",
      "IsEndomorphismHigherDimensionalDomain",
      "IsAutomorphismHigherDimensionalDomain" ]

##### 8.3-4 InclusionMorphismHigherDimensionalDomains

`‣ InclusionMorphismHigherDimensionalDomains`( obj, sub ) | ( operation )

#### 8.4 Definitions and constructions for cat^2-groups and their morphisms

We shall give three definitions of cat^2-groups and show that they are equivalent. When we come to define cat^n-groups we shall give a similar set of three definitions.

Firstly, we take the definition of a cat^2-group from Section 5 of Brown and Loday [BL87], suitably modified. A cat^2-group mathcalC = (C_[2],C_{2},C_{1},C_∅) comprises four groups (one for each of the subsets of [2]) and 15 homomorphisms, as shown in the following diagram:

\vcenter{\xymatrix{ & C_{[2]} \ar[ddd] <-1.2ex> \ar[ddd] <-2.0ex>_{\ddot{t}_2,\ddot{h}_2} \ar[rrr] <+1.2ex> \ar[rrr] <+2.0ex>^{\ddot{t}_1,\ddot{h}_1} \ar[dddrrr] <-0.2ex> \ar[dddrrr] <-1.0ex>_(0.55){t_{[2]},h_{[2]}} &&& C_{\{2\}} \ar[lll]^{\ddot{e}_1} \ar[ddd]<+1.2ex> \ar[ddd] <+2.0ex>^{\dot{t}_2,\dot{h}_2} \\ \mathcal{C} \quad = \quad & &&& \\ & &&& \\ & C_{\{1\}} \ar[uuu]_{\ddot{e}_2} \ar[rrr] <-1.2ex> \ar[rrr] <-2.0ex>_{\dot{t}_1,\dot{h}_1} &&& C_{\emptyset} \ar[uuu]^{\dot{e}_2} \ar[lll]_{\dot{e}_1} \ar[uuulll] <-1.0ex>_{e_{[2]}} \\ }}

The following axioms are satisfied by these homomorphisms:

- the four sides of the square are cat^1-groups, denoted ddotmathcalC}_1, ddotmathcalC}_2, dotmathcalC}_1, dotmathcalC}_2,

- dott_1∘ddoth_2 = doth_2∘ddott_1, ~ dott_2∘ddoth_1 = doth_1∘ddott_2, ~ dote_1∘dott_2 = ddott_2∘ddote_1, ~ dote_2∘dott_1 = ddott_1∘ddote_2, ~ dote_1∘doth_2 = ddoth_2∘ddote_1, ~ dote_2∘doth_1 = ddoth_1∘ddote_2,

- dott_1∘ddott_2 = dott_2∘ddott_1 = t_[2], ~ doth_1∘ddoth_2 = doth_2∘ddoth_1 = h_[2], ~ dote_1∘ddote_2 = dote_2∘ddote_1 = e_[2], making the diagonal a pre-cat^1-group (e_[2]; t_[2], h_[2] : C_[2] -> C_∅).

It follows from these identities that (ddott_1,dott_1),(ddoth_1,doth_1) and (ddote_1,dote_1) are morphisms of cat^1-groups.

Secondly, we give the simplest of the three definitions, adapted from Ellis-Steiner [ES87]. A cat^2-group mathcalC consists of groups G, R_1,R_2 and six homomorphisms t_1,h_1 : G -> R_2,~ e_1 : R_2 -> G,~ t_2,h_2 : G -> R_1,~ e_2 : R_1 -> G, satisfying the following axioms for all 1 leqslant i leqslant 2,

- (t_i ∘ e_i)r = r,~ (h_i ∘ e_i)r = r,~ ∀ r ∈ R_[2] ∖ {i}, quad [ker t_i, ker h_i] = 1,

- (e_1 ∘ t_1) ∘ (e_2 ∘ t_2) = (e_2 ∘ t_2) ∘ (e_1 ∘ t_1), quad (e_1 ∘ h_1) ∘ (e_2 ∘ h_2) = (e_2 ∘ h_2) ∘ (e_1 ∘ h_1),

- (e_1 ∘ t_1) ∘ (e_2 ∘ h_2) = (e_2 ∘ h_2) ∘ (e_1 ∘ t_1), quad (e_2 ∘ t_2) ∘ (e_1 ∘ h_1) = (e_1 ∘ h_1) ∘ (e_2 ∘ t_2).

Our third definition defines a cat^2-group as a "cat^1-group of cat^1-groups". A cat^2-group mathcalC consists of two cat^1-groups mathcalC_1 = (e_1;t_1,h_1 : G_1 -> R_1) and mathcalC_2 = (e_2;t_2,h_2 : G_2 -> R_2) and cat^1-morphisms t = (ddott,dott), h = (ddoth,doth) : mathcalC_1 -> mathcalC_2, e = (ddote,dote) : mathcalC_2 -> mathcalC_1, subject to the following conditions:

(t \circ e) ~\mbox{and}~ (h \circ e) ~\mbox{are the identity mapping on}~ \mathcal{C}_2, \qquad [\ker t, \ker h] = \{ 1_{\mathcal{C}_1} \},

where ker t = (ker ddott, ker dott), and similarly for ker h.

##### 8.4-1 Cat2Group

`‣ Cat2Group`( args ) | ( function )

`‣ PreCat2Group`( args ) | ( function )

`‣ IsCat2Group`( C ) | ( property )

`‣ PreCat2GroupByPreCat1Groups`( L ) | ( operation )

The global functions `Cat2Group` and `PreCat2Group` are normally called with a single argument, a list of cat1-groups.

    gap> a := (1,2,3,4)(5,6,7,8);;
    gap> b := (1,5)(2,6)(3,7)(4,8);;
    gap> c := (2,6)(4,8);;
    gap> G16 := Group( a, b, c );;
    gap> SetName( G16, "c4c2:c2" );
    gap> t1a := GroupHomomorphismByImages( G16, G16, [a,b,c], [(),(),c] );;
    gap> C1a := PreCat1GroupByEndomorphisms( t1a, t1a );;
    gap> t1b := GroupHomomorphismByImages( G16, G16, [a,b,c], [a,(),()] );;
    gap> C1b := PreCat1GroupByEndomorphisms( t1b, t1b );;
    gap> C16 := Cat2Group( C1a, C1b );
    cat2-group with generating (pre-)cat1-groups:
    1 : [c4c2:c2 => Group( [ (), (), (2,6)(4,8) ] )]
    2 : [c4c2:c2 => Group( [ (1,2,3,4)(5,6,7,8), (), () ] )]
    gap> IsCat2Group( C16 );
    true
    gap> IsCat1Group( Diagonal2DimensionalGroup( C16 ) );
    false

##### 8.4-2 Cat2GroupMorphism

`‣ Cat2GroupMorphism`( args ) | ( function )

`‣ Cat2GroupMorphismByCat1GroupMorphisms`( src, rng, mors ) | ( operation )

`‣ Cat2GroupMorphismByGroupHomomorphisms`( src, rng, mors ) | ( operation )

`‣ PreCat2GroupMorphismByPreCat1GroupMorphisms`( src, rng, mors ) | ( operation )

`‣ PreCat2GroupMorphismByGroupHomomorphisms`( src, rng, mors ) | ( operation )

##### 8.4-3 Cat2GroupOfCrossedSquare

`‣ Cat2GroupOfCrossedSquare`( xsq ) | ( attribute )

`‣ CrossedSquareOfCat2Group`( CC ) | ( attribute )

These functions are very experimental!

These functions provide the conversion from crossed square to cat2-group, and conversely. (They are the 3-dimensional equivalents of `Cat1GroupOfXMod` (2.5-2) and `XModOfCat1Group` (2.5-2).)

    gap> xsC16 := CrossedSquareOfCat2Group( C16 );
    crossed square with crossed modules:
          up = [Group( [ (1,5)(2,6)(3,7)(4,8) ] ) -> Group( [ ( 2, 6)( 4, 8) ] )]
        left = [Group( [ (1,5)(2,6)(3,7)(4,8) ] ) -> Group(
    [ (1,2,3,4)(5,6,7,8), (), () ] )]
       right = [Group( [ ( 2, 6)( 4, 8) ] ) -> Group( () )]
        down = [Group( [ (1,2,3,4)(5,6,7,8), (), () ] ) -> Group( () )]

    gap> IdGroup( xsC16 );
    [ [ 2, 1 ], [ 2, 1 ], [ 4, 1 ], [ 1, 1 ] ]

    gap> SetName( Source( Right2DimensionalGroup( XSact ) ), "c5:c4" );
    gap> SetName( Range( Right2DimensionalGroup( XSact ) ), "c5:c4" );
    gap> Name( XSact );
    "[d10a->c5:c4,d20->c5:c4]"

    gap> C2act := Cat2GroupOfCrossedSquare( XSact );
    cat2-group with generating (pre-)cat1-groups:
    1 : [((c5:c4 |X c5:c4) |X (d20 |X d10a))=>(c5:c4 |X c5:c4)]
    2 : [((c5:c4 |X c5:c4) |X (d20 |X d10a))=>(c5:c4 |X d20)]
    gap> Size( C2act );
    [ 80000, 400, 400, 20 ]

#### 8.5 Definition and constructions for cat^n-groups and their morphisms

In this chapter we are interested in cat^2-groups, but it is convenient in this section to give the more general definition. There are three equivalent description of a cat^n-group.

A cat^n-group consists of the following.

- 2^n groups G_A, one for each subset A of [n], the vertices of an n-cube.

- Group homomorphisms forming n2^n-1 commuting cat^1-groups,

  \mathcal{C}_{A,i} ~=~ (e_{A,i};\; t_{A,i},\; h_{A,i} \ :\ G_A \to G_{A \setminus \{i\}}), \quad\mbox{for all} \quad A \subseteq [n],~ i \in A,

  the edges of the cube.

- These cat^1-groups combine (in sets of 4) to form n(n-1)2^n-3 cat^2-groups mathcalC_A,{i,j} for all {i,j} ⊆ A ⊆ [n],~ i ≠ j, the faces of the cube.

Note that, since the t_A,i, h_A,i and e_A,i commute, composite homomorphisms t_A,B, h_A,B : G_A -> G_A ∖ B and e_A,B : G_A ∖ B -> G_A are well defined for all B ⊆ A ⊆ [n].

Secondly, we give the simplest of the three descriptions, again adapted from Ellis-Steiner [ES87].

A cat^n-group mathcalC consists of 2^n groups G_A, one for each subset A of [n], and 3n homomorphisms

t_{[n],i}, h_{[n],i} : G_{[n]} \to G_{[n] \setminus \{i\}},~ e_{[n],i} : G_{[n] \setminus \{i\}} \to G_{[n]},

satisfying the following axioms for all 1 leqslant i leqslant n,}

- the mathcalC_[n],i ~=~ (e_[n],i; t_[n],i, h_[n],i : G_[n] -> G_[n] ∖ {i})~ are commuting cat^1-groups, so that:

- (e_1 ∘ t_1) ∘ (e_2 ∘ t_2) = (e_2 ∘ t_2) ∘ (e_1 ∘ t_1), quad (e_1 ∘ h_1) ∘ (e_2 ∘ h_2) = (e_2 ∘ h_2) ∘ (e_1 ∘ h_1),

- (e_1 ∘ t_1) ∘ (e_2 ∘ h_2) = (e_2 ∘ h_2) ∘ (e_1 ∘ t_1), quad (e_2 ∘ t_2) ∘ (e_1 ∘ h_1) = (e_1 ∘ h_1) ∘ (e_2 ∘ t_2).

Our third description defines a cat^n-group as a "cat^1-group of cat^(n-1)-groups".

A cat^n-group mathcalC consists of two cat^(n-1)-groups:

- mathcalA with groups G_A, A ⊆ [n-1], and homomorphisms ddott_A,i, ddoth_A,i, ddote_A,i,

- mathcalB with groups H_B, B ⊆ [n-1], and homomorphisms dott_B,i, doth_B,i, dote_B,i, and

- cat^(n-1)-morphisms t,h : mathcalA -> mathcalB and e : mathcalB -> mathcalA subject to the following conditions:

  (t \circ e) ~\mbox{and}~ (h \circ e) ~\mbox{are the identity mapping on}~ \mathcal{B}, \qquad [\ker t, \ker h] = \{ 1_{\mathcal{A}} \}.

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

generated by GAPDoc2HTML