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.
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 calS 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{\calS}_1 = (\kappa : L \to M), \quad \ddot{\calS}_2 = (\lambda : L \to N), \quad \dot{\calS}_2 = (\mu : M \to P), \quad \dot{\calS}_1 = (\nu : N \to P),
and the diagonal
\calS_{12} = (\partial_{12} := \mu \circ \kappa = \nu \circ \lambda : L \to P)
are crossed modules (with actions via P).
These will be called the up, left, right, down and diagonal crossed modules of calS.
⊠ 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).
κ(n ⊠ m) = (m^-1)^n m quad mboxand quad λ(n ⊠ m) = n^-1 n^m.
(n ⊠ κ l) = (l^-1)^n l quad mboxand quad (λ 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}^{\mu(m^n)} \;=\; {n_1}^{n^{-1}(\mu 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.
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 great deal to be done.
‣ CrossedSquareByXMods( up, left, right, down, diag, pairing ) | ( operation ) |
‣ PreCrossedSquareByPreXMods( up, left, right, down, diag, pairing ) | ( operation ) |
If up,left,right,down,diag are five (pre-)crossed modules whose sources and ranges agree, as above, then we just have to add a crossed pairing to complete the data for a (pre-)crossed square.
The Display function is used to print details of 3d-groups.
We take as our example a simple, but significant case. We start with five crossed modules formed from subgroups of D_8 with generators [(1,2,3,4),(3,4). The result is a pre-crossed square which is not a crossed square.
gap> b := (2,4);; c := (1,2)(3,4);; p := (1,2,3,4);; gap> d8 := Group( b, c );; gap> SetName( d8, "d8" );; gap> L := Subgroup( d8, [p^2] );; gap> M := Subgroup( d8, [b] );; gap> N := Subgroup( d8, [c] );; gap> P := TrivialSubgroup( d8 );; gap> kappa := GroupHomomorphismByImages( L, M, [p^2], [b] );; gap> lambda := GroupHomomorphismByImages( L, N, [p^2], [c] );; gap> delta := GroupHomomorphismByImages( L, P, [p^2], [()] );; gap> mu := GroupHomomorphismByImages( M, P, [b], [()] );; gap> nu := GroupHomomorphismByImages( N, P, [c], [()] );; gap> up := XModByTrivialAction( kappa );; gap> left := XModByTrivialAction( lambda );; gap> diag := XModByTrivialAction( delta );; gap> right := XModByTrivialAction( mu );; gap> down := XModByTrivialAction( nu );; gap> xp := CrossedPairingByCommutators( N, M, L );; gap> Print( "xp([c,b]) = ", ImageElmCrossedPairing( xp, [c,b] ), "\n" ); xp([c,b]) = (1,3)(2,4) gap> PXS := PreCrossedSquareByPreXMods( up, left, right, down, diag, xp );; gap> Display( PXS ); (pre-)crossed square with (pre-)crossed modules: up = [Group( [ (1,3)(2,4) ] ) -> Group( [ (2,4) ] )] left = [Group( [ (1,3)(2,4) ] ) -> Group( [ (1,2)(3,4) ] )] right = [Group( [ (2,4) ] ) -> Group( () )] down = [Group( [ (1,2)(3,4) ] ) -> Group( () )] gap> IsCrossedSquare( PXS ); false
‣ Size3d( XS ) | ( attribute ) |
Just as Size2d was used in place of Size for crossed modules, so Size3d is used for crossed squares: Size3d( XS ) returns a four-element list containing the sizes of the four groups at the corners of the square.
gap> Size3d( PXS ); [ 2, 2, 2, 1 ]
‣ CrossedSquareByNormalSubgroups( L, M, N, P ) | ( operation ) |
‣ CrossedPairingByCommutators( N, M, L ) | ( 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 comes 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 ] gap> xpc := CrossedPairing( XSconj );; gap> ImageElmCrossedPairing( xpc, [ p2, p12 ] ); (1,9,7,5,3)(2,10,8,6,4)
‣ CrossedSquareByNormalSubXMod( X0, X1 ) | ( operation ) |
‣ CrossedPairingBySingleXModAction( X0, X1 ) | ( operation ) |
If calX_1 = (∂_1 : S_1 -> R_1) is a normal sub-crossed module of calX_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 ] gap> xp20 := CrossedPairing( XS20 );; gap> ImageElmCrossedPairing( xp20, [ p1^2, p2 ] ); (1,7,3,9,5)(2,8,4,10,6)
‣ ActorCrossedSquare( X0 ) | ( attribute ) |
‣ CrossedPairingByDerivations( X0 ) | ( operation ) |
The actor calA(calX_0) of a crossed module calX_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 (r,\chi) \,\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] gap> W := Range( Up2DimensionalGroup( XSact ) ); c5:c4 gap> w1 := GeneratorsOfGroup( W )[1]; (1,2)(3,4)(5,18)(6,17)(7,20)(8,19)(9,14)(10,13)(11,16)(12,15) gap> xpa := CrossedPairing( XSact );; gap> ImageElmCrossedPairing( xpa, [ p1, w1 ] ); (1,9,7,5,3)(2,10,8,6,4)
‣ CrossedSquareByAutomorphismGroup( G ) | ( operation ) |
‣ CrossedPairingByConjugators( 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)" ] gap> I20 := Range( Up2DimensionalGroup( AXS20 ) );; gap> genI20 := GeneratorsOfGroup( I20 ); [ ^(1,2,3,4,5,6,7,8,9,10), ^(2,10)(3,9)(4,8)(5,7) ] gap> xpi := CrossedPairing( AXS20 );; gap> ImageElmCrossedPairing( xpi, [ genI20[1], genI20[2] ] ); (1,9,7,5,3)(2,10,8,6,4)
‣ CrossedSquareByPullback( X1, X2 ) | ( operation ) |
If crossed modules calX_1 = (ν : N -> P) and calX_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 below uses the central extension crossed module X12=(D12->S3) which was constructed in subsection (XModByCentralExtension (2.1-5)), with pullback group D12xC2.
gap> dn := Down2DimensionalGroup( XSconj );; gap> rt := Right2DimensionalGroup( XSconj );; gap> XSP := CrossedSquareByPullback( dn, rt ); [ (d10b x_d20 d10a) -> d10a ] [ | | ] [ d10b -> d20 ] gap> StructureDescription( XSP ); [ "C5", "D10", "D10", "D20" ] gap> XS12 := CrossedSquareByPullback( X12, X12 );; gap> StructureDescription( XS12 ); [ "C2 x C2 x S3", "D12", "D12", "S3" ] gap> xp12 := CrossedPairing( XS12 );; gap> ImageElmCrossedPairing( xp12, [ (1,2,3,4,5,6), (2,6)(3,5) ] ); (1,5,3)(2,6,4)(7,11,9)(8,12,10)
‣ CrossedSquareByXModSplitting( X0 ) | ( attribute ) |
‣ CrossedPairingByPreImages( X1, X2 ) | ( operation ) |
For calX = (∂ : 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 calX, and the crossed pairing is given by commutators of preimages.
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]" gap> xp12 := CrossedPairing( XS12 );; gap> ImageElmCrossedPairing( xp12, [ (1,2,3,4,5,6), (2,6)(3,5) ] ); (1,5,3)(2,6,4)(7,11,9)(8,12,10) gap> XSS20; [d10a->d10a,d10a->d20] gap> xps := CrossedPairing( XSS20 );; gap> ImageElmCrossedPairing( xps, [ p1^2, p2 ] ); (1,7,3,9,5)(2,8,4,10,6)
‣ 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)" ]
‣ Transpose3DimensionalGroup( S0 ) | ( attribute ) |
The transpose of a crossed square calS is the crossed square tildecalS 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 ]
‣ CentralQuotient( X0 ) | ( attribute ) |
The central quotient of a crossed module calX = (∂ : S -> R) is the crossed square where:
the left crossed module is calX;
the right crossed module is the quotient calX/Z(calX) (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(calX,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" ]
‣ IsCrossedSquare( obj ) | ( property ) |
‣ IsPreCrossedSquare( obj ) | ( property ) |
‣ Is3dObject( obj ) | ( property ) |
‣ IsPerm3dObject( obj ) | ( property ) |
‣ IsPc3dObject( obj ) | ( property ) |
‣ IsFp3dObject( obj ) | ( property ) |
These are the basic properties for 3d-groups, and crossed squares in particular.
‣ Up2DimensionalGroup( XS ) | ( attribute ) |
‣ Left2DimensionalGroup( XS ) | ( attribute ) |
‣ Down2DimensionalGroup( XS ) | ( attribute ) |
‣ Right2DimensionalGroup( XS ) | ( attribute ) |
‣ CrossDiagonalActions( XS ) | ( attribute ) |
‣ Diagonal2DimensionalGroup( XS ) | ( attribute ) |
‣ Name( S0 ) | ( method ) |
These are the basic attributes of a crossed square calS. The six objects used in the construction of calS 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 (see the next subsection). The diagonal crossed module (L -> P) is an additional attribute.
gap> Up2DimensionalGroup( XSconj ); [c5d->d10a] gap> Right2DimensionalGroup( XSact ); Actor[d10a->d20] gap> Name( XSconj ); "[c5d->d10a,d10b->d20]" gap> cross1 := CrossDiagonalActions( XSconj )[1];; gap> gensa := GeneratorsOfGroup( d10a );; gap> gensb := GeneratorsOfGroup( d10a );; gap> act1 := ImageElm( cross1, gensb[1] );; gap> gensa[2]; ImageElm( act1, gensa[2] ); (2,10)(3,9)(4,8)(5,7) (1,5)(2,4)(6,10)(7,9)
‣ IsSymmetric3DimensionalGroup( obj ) | ( property ) |
‣ IsAbelian3DimensionalGroup( obj ) | ( property ) |
‣ IsTrivialAction3DimensionalGroup( obj ) | ( property ) |
‣ IsNormalSub3DimensionalGroup( obj ) | ( property ) |
‣ IsCentralExtension3DimensionalGroup( obj ) | ( property ) |
‣ IsAutomorphismGroup3DimensionalGroup( obj ) | ( property ) |
These are further properties for 3d-groups, and crossed squares in particular. A 3d-group is symmetric if its Up2DimensionalGroup is equal to its Left2DimensionalGroup.
‣ CrossedPairing( XS ) | ( attribute ) |
‣ CrossedPairingMap( xpair ) | ( attribute ) |
‣ ImageElmCrossedPairing( XS, pair ) | ( operation ) |
‣ Mapping2ArgumentsByFunction( MxN, L, map ) | ( operation ) |
Crossed pairings have been implemented using an operation Mapping2ArgumentsByFunction. This encodes a map {M,N} -> L as a map M × N -> L.
The operation ImageElmCrossedPairing returns the image when a crossed pairing {M,N} -> L is applied to the pair [m,n] with m ∈ M,~ n ∈ N.
The first example shows the crossed pairing in the crossed square XSconj.
gap> xp := CrossedPairing( XSconj ); crossed pairing: Group( [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1,10)( 2, 9)( 3, 8)( 4, 7)( 5, 6), (11,13,15,17,19)(12,14,16,18,20), (12,20)(13,19)(14,18)(15,17) ] ) -> c5d 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)
The second example shows how to construct a crossed pairing.
gap> F := FreeGroup(1);; gap> x := GeneratorsOfGroup(F)[1];; gap> z := GroupHomomorphismByImages( F, F, [x], [x^0] );; gap> id := GroupHomomorphismByImages( F, F, [x], [x] );; gap> map := Mapping2ArgumentsByFunction( [F,F], F, function(c) > return x^(ExponentSumWord(c[1],x)*ExponentSumWord(c[2],x)); end );; gap> h := CrossedPairingObj( [F,F], F, map );; gap> ImageElmCrossedPairing( h, [x^3,x^4] ); f1^12 gap> A := AutomorphismGroup( F );; gap> a := GeneratorsOfGroup(A)[1];; gap> act := GroupHomomorphismByImages( F, A, [x], [a^2] );; gap> X0 := XModByBoundaryAndAction( z, act );; gap> X1 := XModByBoundaryAndAction( id, act );; gap> XSF := PreCrossedSquareByPreXMods( X0, X0, X1, X1, X0, h );; gap> IsCrossedSquare( XSF ); true
This section describes an initial implementation of morphisms of (pre-)crossed squares.
‣ CrossedSquareMorphism( args ) | ( function ) |
‣ CrossedSquareMorphismByXModMorphisms( src, rng, mors ) | ( operation ) |
‣ CrossedSquareMorphismByGroupHomomorphisms( src, rng, homs ) | ( operation ) |
‣ PreCrossedSquareMorphismByPreXModMorphisms( src, rng, mors ) | ( operation ) |
‣ PreCrossedSquareMorphismByGroupHomomorphisms( src, rng, homs ) | ( operation ) |
‣ 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.
‣ IsCrossedSquareMorphism( map ) | ( property ) |
‣ IsPreCrossedSquareMorphism( map ) | ( property ) |
‣ IsBijective( mor ) | ( method ) |
‣ IsEndomorphism3dObject( mor ) | ( property ) |
‣ IsAutomorphism3dObject( mor ) | ( property ) |
A morphism mor between two pre-crossed squares calS_1 and calS_2 consists of four crossed module morphisms Up2DimensionalMorphism(mor), mapping the Up2DimensionalGroup of calS_1 to that of calS_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" ]
‣ InclusionMorphismHigherDimensionalDomains( obj, sub ) | ( operation ) |
We give here three equivalent definitions of cat^2-groups. When we come to define cat^n-groups we shall give a similar set of 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 calC = (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} \\ \calC \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 (up, left, right, down) are cat^1-groups, denoted ddotcalC_1, ddotcalC_2, dotcalC_1, dotcalC_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, and similarly in the vertical direction.
Secondly, we give the simplest of the three definitions, adapted from Ellis-Steiner [ES87]. A cat^2-group calC 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 calC consists of two cat^1-groups calC_1 = (e_1;t_1,h_1 : G_1 -> R_1) and calC_2 = (e_2;t_2,h_2 : G_2 -> R_2) and cat^1-morphisms t = (ddott,dott), h = (ddoth,doth) : calC_1 -> calC_2, e = (ddote,dote) : calC_2 -> calC_1, subject to the following conditions:
(t \circ e) ~\mbox{and}~ (h \circ e) ~\mbox{are the identity mapping on}~ \calC_2, \qquad [\ker t, \ker h] = \{ 1_{\calC_1} \},
where ker t = (ker ddott, ker dott), and similarly for ker h.
A recent paper Computing 3-Dimensional Groups :L Crossed Squares and Cat2-Groups, by Arvasi, Odabas and Wensley [AOWar], contains tables listing the numbers of isomorphism classes of cat2-groups on groups of order at most 30 – a total of 1007 cat2-groups.
‣ Cat2Group( args ) | ( function ) |
‣ PreCat2Group( args ) | ( function ) |
‣ IsCat2Group( C ) | ( property ) |
‣ PreCat2GroupByPreCat1Groups( L ) | ( operation ) |
The global functions Cat2Group and PreCat2Group are normally called with two arguments - the generating up and left cat^1-groups - or with a single argument which is a crossed square. The operation PreCat2GroupByPreCat1Groups has five arguments - the up, left, right, down and diagonal cat^1-groups.
The two cat^2-groups C2a, C2b constructed in the following example are isomorphic. They differ in the down-left group P.
gap> a := (1,2,3,4,5,6);; b := (2,6)(3,5);; gap> G := Group( a, b );; SetName( G, "d12" ); gap> t1 := GroupHomomorphismByImages( G, G, [a,b], [a^3,b] );; gap> up := PreCat1GroupByEndomorphisms( t1, t1 );; gap> t2 := GroupHomomorphismByImages( G, G, [a,b], [a^4,b] );; gap> left := PreCat1GroupByEndomorphisms( t2, t2 );; gap> C2a := Cat2Group( up, left ); (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] gap> IsCat2Group( C2a ); true gap> genR := [ (1,4)(2,5)(3,6), (2,6)(3,5) ];; gap> R := Subgroup( G, genR );; gap> genQ := [ (1,3,5)(2,4,6), (2,6)(3,5) ];; gap> Q := Subgroup( G, genQ );; gap> Pa := Group( b );; SetName( Pa, "c2a" ); gap> Pb := Group( (7,8) );; SetName( Pb, "c2b" ); gap> t3 := GroupHomomorphismByImages( R, P, genR, [(),(7,8)] );; gap> e3 := GroupHomomorphismByImages( P, R, [(7,8)], [(2,6)(3,5)] );; gap> right := PreCat1GroupByTailHeadEmbedding( t3, t3, e3 );; gap> t4 := GroupHomomorphismByImages( Q, P, genQ, [(),(7,8)] );; gap> e4 := GroupHomomorphismByImages( P, Q, [(7,8)], [(2,6)(3,5)] );; gap> down := PreCat1GroupByTailHeadEmbedding( t4, t4, e4 );; gap> t0 := t1 * t3;; gap> e0 := GroupHomomorphismByImages( P, G, [(7,8)], [(2,6)(3,5)] );; gap> diag := PreCat1GroupByTailHeadEmbedding( t0, t0, e0 );; gap> C2b := PreCat2GroupByPreCat1Groups( up, left, right, down, diag ); (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] gap> IsPreCatnGroupWithIdentityEmbeddings( C2b ); false
‣ DirectProduct( C2a, C2b ) | ( operation ) |
The direct product calC_1 × calC_2 has as its four up, left, right and down cat^1-groups the direct products of those in calC_1 and calC_2. The embeddings and projections are constructed automatically, and placed in the DirectProductInfo attribute, together with the two objects calC_1 and calC_2.
gap> C2ab := DirectProductOp( [ C2a, C2b ], C2a ); (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [Group( [ (1,2,3,4,5,6), (2,6)(3,5), ( 7, 8, 9,10,11,12), ( 8,12)( 9,11) ] ) => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5), ( 7,10)( 8,11)( 9,12), ( 8,12)( 9,11) ] )] 2 : [Group( [ (1,2,3,4,5,6), (2,6)(3,5), ( 7, 8, 9,10,11,12), ( 8,12)( 9,11) ] ) => Group( [ (1,5,3)(2,6,4), (2,6)(3,5), ( 7, 9,11)( 8,10,12), ( 8,12)( 9,11) ] )] gap> StructureDescription( C2ab ); [ "C2 x C2 x S3 x S3", "C2 x C2 x C2 x C2", "S3 x S3", "C2 x C2" ] gap> SetName( C2ab, "C2ab" ); gap> Embedding( C2ab, 1 ); <mapping: (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] -> C2ab > gap> Projection( C2ab, 2 ); <mapping: C2ab -> (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] >
‣ DisplayLeadMaps( C0 ) | ( operation ) |
This operation provides an alternative to Display giving a shorter output. Generators of the up-left group are output, together with their images under the up and left tail and head maps.
gap> DisplayLeadMaps( C2b ); (pre-)cat2-group with up-left group: [ (1,2,3,4,5,6), (2,6)(3,5) ] up tail=head images: [ (1,4)(2,5)(3,6), (2,6)(3,5) ] left tail=head images: [ (1,5,3)(2,6,4), (2,6)(3,5) ]
‣ Transpose3DimensionalGroup( S0 ) | ( attribute ) |
The transpose of a cat^2-group calC with groups [G,R,Q,P] is the cat^2-group tildecalC with groups [G,Q,R,P].
gap> TC2a := Transpose3DimensionalGroup( C2a ); (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
‣ Cat2GroupMorphism( args ) | ( function ) |
‣ Cat2GroupMorphismByCat1GroupMorphisms( src, rng, upmor, ltmor ) | ( operation ) |
‣ Cat2GroupMorphismByGroupHomomorphisms( src, rng, homs ) | ( operation ) |
‣ PreCat2GroupMorphism( args ) | ( function ) |
‣ PreCat2GroupMorphismByPreCat1GroupMorphisms( src, rng, upmor, ltmor ) | ( operation ) |
‣ PreCat2GroupMorphismByGroupHomomorphisms( src, rng, homs ) | ( operation ) |
A (pre-)cat^2-group morphism μ : calC = (G,R,Q,P) -> calC' = (G',R',Q',P') is a list of four group homomorphisms γ : G -> G',~ ρ : R -> R',~ ξ : Q -> Q' and π : P -> P' which commute with all the tail, head and embedding maps so that (γ,ρ), (γ,ξ), (ρ,π) and (ξ,π) are all (pre-)cat^1-group morphisms.
For the operations (Pre)Cat2GroupMorphismByPreCat1GroupMorphisms the third and fourth parameters upmor, ltmor are two cat^1-group morphisms with source the up and left cat^1-groups in calC.
For the operations (Pre)Cat2GroupMorphismByGroupHomomorphisms the third parameter mors is the list [γ,ρ,ξ,π].
The example constructs an automorphism of c2a is two ways, using the two methods described above, an d verifies that the result is the same in each case.
gap> gamma := GroupHomomorphismByImages( G, G, [a,b], [a^-1,b] );; gap> rho := IdentityMapping( R );; gap> xi := GroupHomomorphismByImages( Q, Q, [a^2,b], [a^-2,b] );; gap> pi := IdentityMapping( Pa );; gap> homs := [ gamma, rho, xi, pi ];; gap> mor1 := Cat2GroupMorphismByGroupHomomorphisms( C2a, C2a, homs ); <mapping: (pre-)cat2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] -> (pre-)cat 2-group with generating (pre-)cat1-groups: 1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )] 2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] > gap> upmor := Cat1GroupMorphism( up, up, gamma, rho );; gap> ltmor := Cat1GroupMorphism( left, left, gamma, xi );; gap> mor2 := Cat2GroupMorphismByCat1GroupMorphisms( C2a, C2a, upmor, ltmor );; gap> mor1 = mor2; true
‣ Cat2GroupOfCrossedSquare( xsq ) | ( attribute ) |
‣ CrossedSquareOfCat2Group( CC ) | ( attribute ) |
These functions provide for conversion between crossed squares and cat^2-groups. (They are the 3-dimensional equivalents of Cat1GroupOfXMod (2.5-3) and XModOfCat1Group (2.5-3).) The actor crossed square XSact was constructed in section ActorCrossedSquare (8.2-5).
gap> xsC2a := CrossedSquareOfCat2Group( C2a ); crossed square with crossed modules: up = [Group( () ) -> Group( [ (1,4)(2,5)(3,6) ] )] left = [Group( () ) -> Group( [ (1,3,5)(2,4,6) ] )] right = [Group( [ (1,4)(2,5)(3,6) ] ) -> Group( [ (2,6)(3,5) ] )] down = [Group( [ (1,3,5)(2,4,6) ] ) -> Group( [ (2,6)(3,5) ] )] gap> IdGroup( xsC2a ); [ [ 1, 1 ], [ 2, 1 ], [ 3, 1 ], [ 2, 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 ); (pre-)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> Size3d( C2act ); [ 80000, 400, 400, 20 ]
‣ Subdiagonal2DimensionalGroup( obj ) | ( attribute ) |
The diagonal of a crossed square is always a crossed module, but the diagonal of a cat^2-group need only be a pre-cat^1-group. There is, however, a sub-cat^1-group of this diagonal which, in the case of a cat^2-group constructed from a crossed square, is (P ⋉ L => P). (The name of this operation is very provisional.)
gap> G24 := SmallGroup( 24, 10 );; gap> w := G24.1;; x := G24.2;; y := G24.3;; z := G24.4;; o := One(G24);; gap> R := Subgroup( G24, [x,y] );; gap> txy := GroupHomomorphismByImages( G24, R, [w,x,y,z], [o,x,y,o] );; gap> exy := GroupHomomorphismByImages( R, G24, [x,y], [x,y] );; gap> C1xy := PreCat1GroupByTailHeadEmbedding( txy, txy, exy );; gap> Q := Subgroup( G24, [w,y] );; gap> twy := GroupHomomorphismByImages( G24, Q, [w,x,y,z], [w,o,y,o] );; gap> ewy := GroupHomomorphismByImages( Q, G24, [w,y], [w,y] );; gap> C1wy := PreCat1GroupByTailHeadEmbedding( twy, twy, ewy );; gap> C2wxy := PreCat2Group( C1xy, C1xy );; gap> dg := Diagonal2DimensionalGroup( C2wxy );; gap> IsCat1Group( dg ); false gap> C1sub := Subdiagonal2DimensionalGroup( C2wxy );; gap> IsCat1Group( C1sub ); true gap> IsSub2DimensionalGroup( dg, C1sub ); true
This section mirrors that for cat^1-groups (2.6). As the size of a group G increases, the number of cat^2-groups with source G increases rapidly. However, one is usually only interested in the isomorphism classes of cat^2-groups with source G. An iterator AllCat2GroupsIterator is provided, which runs through the various cat^2-groups. This iterator finds, for each unordered pair of subgroups R,Q of G, the cat^2-groups whose Up2DimensionalGroup has range R, and whose Left2DimensionalGroup has range Q. It does this by running through UnoderedPairsIterator(AllSubgroupsIterator(G)) provided by the Utils package, and then using the iterator AllCat2GroupsWithImagesIterator(G,R,Q).
‣ AllCat2GroupsWithImagesIterator( G, R, Q ) | ( operation ) |
‣ AllCat2GroupsWithImagesNumber( G, R, Q ) | ( attribute ) |
‣ AllCat2GroupsWithImages( G, R, Q ) | ( operation ) |
‣ AllCat2GroupsWithImagesUpToIsomorphism( G, R, Q ) | ( operation ) |
The iterator AllCat2GroupsWithImagesIterator(G) iterates through all the cat^2-groups with source G and generating cat^1-groups (G=>R) and (G=>Q). The attribute AllCat2GroupsWithImagesNumber(G) runs through this iterator to determine the number n of these cat^2-groups. The operation AllCat2GroupsWithImages(G) returns a list containing these n cat^2-groups. Since these lists can get very long, this operation should only be used for simple cases. The operation AllCat2GroupsWithImagesUpToIsomorphism(G) returns representatives of the isomorphism classes of these cat^2-groups.
gap> G8 := Group( (1,2), (3,4), (5,6) );; gap> A := Subgroup( G8, [ (1,2) ] );; gap> B := Subgroup( G8, [ (3,4) ] );; gap> AllCat2GroupsWithImagesNumber( G8, A, A ); 4 gap> all := AllCat2GroupsWithImages( G8, A, A );; gap> for C2 in all do DisplayLeadMaps( C2 ); od; (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (1,2), () ] left tail=head images: [ (1,2), (1,2), () ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail=head images: [ (1,2), (), () ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), (1,2) ] left tail=head images: [ (1,2), (), (1,2) ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (1,2), (1,2) ] left tail=head images: [ (1,2), (1,2), (1,2) ] gap> AllCat2GroupsWithImagesNumber( G8, A, B ); 16 gap> iso := AllCat2GroupsWithImagesUpToIsomorphism( G8, A, B );; gap> for C2 in iso do DisplayLeadMaps( C2 ); od; (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail=head images: [ (), (3,4), () ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail/head images: [ (), (3,4), () ], [ (), (3,4), (3,4) ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail/head images: [ (1,2), (), () ], [ (1,2), (), (1,2) ] left tail/head images: [ (), (3,4), () ], [ (), (3,4), (3,4) ]
‣ AllCat2GroupsWithFixedUp( C ) | ( operation ) |
‣ AllCat2GroupsWithFixedUpAndLeftRange( C, R ) | ( operation ) |
The operation AllCat2GroupsWithFixedUp(C) constructs all the cat^2-groups with a fixed Up2DimensionalGroup C. In the second operation the user may also specify the range of the Left2DimensionalGroup.
gap> up := Up2DimensionalGroup( iso[1] ); [Group( [ (1,2), (3,4), (5,6) ] )=>Group( [ (1,2), (), () ] )] gap> AllCat2GroupsWithFixedUp( up );; gap> Length(last); 28 gap> L := AllCat2GroupsWithFixedUpAndLeftRange( up, B );; gap> for C in L do DisplayLeadMaps( C ); od; (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail=head images: [ (), (3,4), () ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail/head images: [ (), (3,4), () ], [ (), (3,4), (3,4) ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail/head images: [ (), (3,4), (3,4) ], [ (), (3,4), () ] (pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ] up tail=head images: [ (1,2), (), () ] left tail=head images: [ (), (3,4), (3,4) ]
‣ AllCat2GroupsMatrix( G ) | ( attribute ) |
The operation AllCat2GroupsMatrix(G) constructs a symmetric matrix M with rows and columns labelled by the cat^1-groups C_i on G, where M_ij is 1 if C_i,C_j combine to form a cat^2-group, and 0 otherwise. The matrix is automatically printed out with dots in place of zeroes.
In the example we see that the dihedral group D_12 has 12 cat^1-groups and 41 cat^2-groups, 12 of which are symmetric. This operation is intended to be used to illustrate how cat^2-groups are formed, and should only be used with groups of low order.
The attribute AllCat2GroupsNumber(G) returns the number n of these cat^2-groups.
gap> AllCat2GroupsMatrix(d12);; number of cat2-groups found = 41 1.....1..1.1 .1.....1.1.1 ..1.....11.1 ...1....1.11 ....1.1...11 .....1.1..11 1...1.1..111 .1...1.1.111 ..11....1111 111...1111.1 ...111111.11 111111111111 gap> AllCat2GroupsNumber(d12); 41
‣ AllCat2GroupsIterator( G ) | ( operation ) |
‣ AllCat2Groups( G ) | ( operation ) |
‣ AllCat2GroupsUpToIsomorphism( G ) | ( operation ) |
‣ AllCat2GroupFamilies( G ) | ( operation ) |
‣ CatnGroupNumbers( G ) | ( attribute ) |
‣ CatnGroupLists( G ) | ( attribute ) |
The iterator AllCat2GroupsIterator(G) iterates through all the cat^2-groups with source G. The operation AllCat2Groups(G) returns a list containing these n cat^2-groups. Since these lists can get very long, this operation should only be used for simple cases. The operation AllCat2GroupsUpToIsomorphism(G) returns representatives of the isomorphism classes of these subgroups. The operation AllCat2GroupFamilies(G) returns a list of lists. The k-th list contains the positions of the cat^2-groups in AllCat2Groups(G) which are isomorphic to the k-th representative. So, for d12, the 41 cat^2-groups form 10 classes, and the sizes of these classes are [6,6,6,6,3,6,3,2,2,1]. Four of these classes contain symmetric cat^2-groups.
The field CatnGroupNumbers(G).cat2 is the number of cat^2-groups on G, while CatnGroupNumbers(G).iso2 is the number of isomorphism classes of these cat^2-groups. Also CatnGroupNumbers(G).symm is the number of cat^2-groups whose Up2DimensionalGroup is the same as the Left2DimensionalGroup, while CatnGroupNumbers(G).siso is the number of isomorphism classes of these symmetric cat^2-groups.
Provided that CatnGroupLists(G).omit is not set to true, sorted lists of generating pairs, and of the classes they belong to, are added to the record CatnGroupLists. For example [5,7] in these lists for d12 indicates that there is a cat^2-group generated by the fifth and seventh cat^1-groups and that this is in the second class whose representative is [1,7]. Classes [1,5,8,10] contain symmetric cat^2-groups.
gap> AllCat2GroupsNumber( d12 ); 41 gap> reps2 := AllCat2GroupsUpToIsomorphism( d12 );; gap> Length( reps2 ); 10 gap> List( reps2, C -> StructureDescription( C ) ); [ [ "D12", "C2", "C2", "C2" ], [ "D12", "C2", "C2 x C2", "C2" ], [ "D12", "C2", "S3", "C2" ], [ "D12", "C2", "D12", "C2" ], [ "D12", "C2 x C2", "C2 x C2", "C2 x C2" ], [ "D12", "C2 x C2", "S3", "C2" ] , [ "D12", "C2 x C2", "D12", "C2 x C2" ], [ "D12", "S3", "S3", "S3" ], [ "D12", "S3", "D12", "S3" ], [ "D12", "D12", "D12", "D12" ] ] gap> fams := AllCat2GroupFamilies( d12 ); [ [ 1, 2, 3, 4, 5, 6 ], [ 7, 8, 10, 11, 13, 14 ], [ 16, 17, 18, 23, 24, 25 ], [ 30, 31, 32, 33, 34, 35 ], [ 9, 12, 15 ], [ 19, 20, 21, 26, 27, 28 ], [ 36, 37, 38 ], [ 22, 29 ], [ 39, 40 ], [ 41 ] ] gap> CatnGroupNumbers( d12 ); rec( cat1 := 12, cat2 := 41, idem := 21, iso1 := 4, iso2 := 10, isopredg := 0, predg := 0, siso := 4, symm := 12 ) gap> CatnGroupLists( d12 ); rec( allcat2pos := [ 1, 7, 9, 16, 19, 22, 30, 36, 39, 41 ], cat2classes := [ [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ], [ 5, 5 ], [ 6, 6 ] ], [ [ 1, 7 ], [ 5, 7 ], [ 2, 8 ], [ 6, 8 ], [ 3, 9 ], [ 4, 9 ] ], [ [ 1, 10 ], [ 2, 10 ], [ 3, 10 ], [ 4, 11 ], [ 5, 11 ], [ 6, 11 ] ], [ [ 1, 12 ], [ 2, 12 ], [ 3, 12 ], [ 4, 12 ], [ 5, 12 ], [ 6, 12 ] ], [ [ 7, 7 ], [ 8, 8 ], [ 9, 9 ] ], [ [ 7, 10 ], [ 8, 10 ], [ 9, 10 ], [ 7, 11 ], [ 8, 11 ], [ 9, 11 ] ], [ [ 7, 12 ], [ 8, 12 ], [ 9, 12 ] ], [ [ 10, 10 ], [ 11, 11 ] ], [ [ 10, 12 ], [ 11, 12 ] ], [ [ 12, 12 ] ] ], cat2pairs := [ [ 1, 1 ], [ 1, 7 ], [ 1, 10 ], [ 1, 12 ], [ 2, 2 ], [ 2, 8 ], [ 2, 10 ], [ 2, 12 ], [ 3, 3 ], [ 3, 9 ], [ 3, 10 ], [ 3, 12 ], [ 4, 4 ], [ 4, 9 ], [ 4, 11 ], [ 4, 12 ], [ 5, 5 ], [ 5, 7 ], [ 5, 11 ], [ 5, 12 ], [ 6, 6 ], [ 6, 8 ], [ 6, 11 ], [ 6, 12 ], [ 7, 7 ], [ 7, 10 ], [ 7, 11 ], [ 7, 12 ], [ 8, 8 ], [ 8, 10 ], [ 8, 11 ], [ 8, 12 ], [ 9, 9 ], [ 9, 10 ], [ 9, 11 ], [ 9, 12 ], [ 10, 10 ], [ 10, 12 ], [ 11, 11 ], [ 11, 12 ], [ 12, 12 ] ], omit := false, pisopos := [ ], sisopos := [ 1, 5, 8, 10 ] )
generated by GAPDoc2HTML