GAP (Gpd) - Chapter 3: Morphisms of Groupoids

Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | Bib | Ind

### 3. Morphisms of Groupoids

A morphism m from a groupoid G to a groupoid H consists of a map from the objects of G to those of H together with a map from the elements of G to those of H which is compatible with tail and head and which preserves multiplication:

\[ m(g1 : o1 \to o2)*m(g2 : o2 \to o3) ~=~ m(g1*g2 : o1 \to o3). \]

Note that when a morphism is not injective on objects, the image of the source need not be a subgroupoid of the range. The simplest example of this is given by mapping the two-object groupoid with trivial group to the free group < a > on one generator, when the image is [1,a,a^-1].

#### 3.1 Morphisms to a connected groupoid

##### 3.1-1 MorphismOfConnectedGroupoids

`> MorphismOfConnectedGroupoids`( G, H, imobs, hom ) | ( function )

`> Source`( mor ) | ( attribute )

`> Range`( mor ) | ( attribute )

`> ComponentImages`( mor ) | ( attribute )

As usual, there are a variety of morphism constructors. The basic construction is a morphism G -> H with H connected, which is implemented as `IsMorphismToConnectedGroupoidRep` with attributes `Source`, `Range` and `ComponentImages`. If G is also connected, we may apply `MorphismOfConnectedGroupoids`, requiring:

- a list `imobs` of the images of the objects of G;

- a homomorphism `hom` from the group of G to the group of H.

    gap> d12 := Group( (15,16,17,18,19,20, (15,20)(16,19)(17,18) );;
    gap> Gd12 := ConnectedGroupoid( [-37,-36,-35,-34], d12 );;
    gap> SetName( d12, "d12" );  SetName( Gd12, "Gd12" );
    gap> s3d := Subgroup( d12, [ (15,17,19)(16,18,20), (15,20)(16,19)(17,18) ] );
    gap> Gs3d := SubgroupoidByComponents( Gd12, [ [[-36,-35,-34], s3d] ] );;
    gap> SetName( s3d, "s3d" );  SetName( Gs3d, "Gs3d" );
    gap> gend8 := GeneratorsOfGroup( d8 );;
    gap> imhd8 := [ ( ), (15,20)(16,19)(17,18) ];;
    gap> hd8 := GroupHomomorphismByImages( d8, s3d, gend8, imhd8 );
    gap> md8 := MorphismOfConnectedGroupoids( Gd8, Gs3d, [-34,-35,-36], hd8 );
    Groupoid morphism : Gd8 -> Gs3d
    gap> IsBijectiveOnObjects( md8 );
    true
    gap> Display( md8 );
    Morphism to connected groupoid:
    [ Gd8 ] -> [ Gs3d ]
      object map = [ [ -9, -8, -7 ], [ -34, -35, -36 ] ]
    homomorphism = [ [ (1,2,3,4), (1,3) ], [ (), (15,20)(16,19)(17,18) ] ]

##### 3.1-2 MorphismToConnectedGroupoid

`> MorphismToConnectedGroupoid`( G, H, obhoms ) | ( function )

`> GroupoidMorphismWithCommonRange`( G, H, mors ) | ( function )

`> GroupoidMorphism`( args ) | ( function )

When G is not connected the appropriate operation is `MorphismToConnectedGroupoid( G, H, obhoms )`, where the third parameter is a list `ComponentImages( mor )` of `[imobs,hom]` pairs.

The operation `GroupoidMorphismWithCommonRange` combines into a single morphism two or more morphisms, in the list `mors`, with range H and source a subgroupoid of G.

The global function `GroupoidMorphism` will normally find the appropriate operation to call.

    gap> hc6 := GroupHomomorphismByImages( c6, s3d, [(5,6,7)(8,9)], [(15,19)(16,18)] );;
    gap> mc6 := GroupoidMorphism( Gc6, Gs3d, [ -36 ], hc6 );;
    gap> md8c6 := MorphismToConnectedGroupoid( Gd8c6, Gs3d,
                  [ [[-34,-35,-36], hd8], [[-36], hc6] ] );
    Groupoid morphism : Gd8+Gc6 -> Gs3d
    gap> Display( md8c6 );
    Morphism to connected groupoid with components:
    [ Gd8 ] -> [ Gs3d ]
      object map = [ [ -9, -8, -7 ], [ -34, -35, -36 ] ]
    homomorphism = [ [ (1,2,3,4), (1,3) ], [ (), (15,20)(16,19)(17,18) ] ]
    [ Gc6 ] -> [ Gs3d ]
      object map = [ [ -6 ], [ -36 ] ]
    homomorphism = [ [ (5,6,7)(8,9) ], [ (15,19)(16,18) ] ]
    gap>
    gap> gens3d := GeneratorsOfGroup( s3d );;
    gap> imas3d := [ (15,17,19)(16,18,20), (15,16)(17,20)(18,19) ];;
    gap> as3d := GroupHomomorphismByImages( s3d, s3d, gens3d, imas3d );;
    gap> aGs3d := MorphismOfConnectedGroupoids( Gs3d, Gs3d, [-35,-34,-36], as3d );;
    gap> IsGroupoidAutomorphism( aGs3d );
    true
    gap> Order( aGs3d );
    3
    gap> Gs3dd8 := GroupoidByUnion( [ Gd8, Gs3d ] );;
    gap> SetName( Gs3dd8, "Gs3d+Gd8" );;
    gap> common := GroupoidMorphismWithCommonRange( Gs3dd8, Gs3d, [ aGs3d, md8 ] );;
    gap> Display( common );
    Morphism to connected groupoid with components:
    [ Gs3d ] -> [ Gs3d ]
      object map = [ [ -36, -35, -34 ], [ -35, -34, -36 ] ]
    homomorphism = [ [ (15,17,19)(16,18,20), (15,20)(16,19)(17,18) ],
      [ (15,17,19)(16,18,20), (15,16)(17,20)(18,19) ] ]
    [ Gd8 ] -> [ Gs3d ]
      object map = [ [ -9, -8, -7 ], [ -34, -35, -36 ] ]
    homomorphism = [ [ (1,2,3,4), (1,3) ], [ (), (15,20)(16,19)(17,18) ] ]

##### 3.1-3 IsomorphismNewObjects

`> IsomorphismNewObjects`( gpd, obs ) | ( operation )

`> IdentityMapping`( gpd ) | ( attribute )

The function `IsomorphismNewObjects` provides an isomorphism to an isomorphic groupoid with a new set of objects. The function `IdentityMapping`, already provided for groups, is also implemented for groupoids.

    gap> idGd8 := IdentityMapping( Gd8 );
    Groupoid morphism: [ Gd8 ] -> [ Gd8 ]
    gap> copys3d := IsomorphismNewObjects( Gs3d, [-24,-25,-26] );;
    gap> Hs3d := Range( copys3d );;
    gap> SetName( Hs3, "Hs3" );
    gap> Display( copys3d );
    Morphism to connected groupoid:
    [ Gs3d ] -> [ Hs3d ]
      object map = [ [ -36, -35, -34 ], [ -32, -31, -30 ] ]
    homomorphism = [ [ (15,17,19)(16,18,20), (15,20)(16,19)(17,18) ],
      [ (15,17,19)(16,18,20), (15,20)(16,19)(17,18) ] ]

##### 3.1-4 InclusionMappingGroupoids

`> InclusionMappingGroupoids`( G, U ) | ( operation )

`> RestrictionMappingGroupoids`( hom, src, rng ) | ( operation )

We have added functions `InclusionMappingGroupoids` and `RestrictionMappingGroupoids`, corresponding to `InclusionMappingGroups` and `RestrictionMappingGroups` for groups. At present `RestrictionMappingGroups` is only implemented for the case where the source and range of the morphism are connected.

    gap> SetName( ComponentsOfGroupoid(Ud8)[1], "Ud8a" );
    gap> SetName( ComponentsOfGroupoid(Ud8)[2], "Ud8b" );
    gap> inc := InclusionMappingGroupoids( Gd8, Ud8 );;
    gap> Display( inc );
    Morphism to connected groupoid with components:
    [ Ud8a ] -> [ Gd8 ]
      object map = [ [ -9 ], [ -9 ] ]
    homomorphism = [ [ (1,2)(3,4), (1,3)(2,4) ], [ (1,2)(3,4), (1,3)(2,4) ] ]
    [ Ud8b ] -> [ Gd8 ]
      object map = [ [ -8, -7 ], [ -8, -7 ] ]
    homomorphism = [ [ (1,2,3,4) ], [ (1,2,3,4) ] ]
    gap> res := RestrictionMappingGroupoids( md8, Ud8, Gs3d );
    gap> Display( res );
    Morphism to connected groupoid with components:
    [ Ud8a ] -> [ Gs3d ]
      object map = [ [ -9 ], [ -34 ] ]
    homomorphism = [ [ (1,2)(3,4), (1,3)(2,4) ], [ (15,20)(16,19)(17,18), () ] ]
    [ Ud8b ] -> [ Gs3d ]
      object map = [ [ -8, -7 ], [ -35, -36 ] ]
    homomorphism = [ [ (1,2,3,4) ], [ () ] ]

#### 3.2 General Morphisms and composites

##### 3.2-1 GroupoidMorphismByComponents

`> GroupoidMorphismByComponents`( G, H, mors ) | ( operation )

`> GroupoidMorphismByUnion`( mors ) | ( function )

When H is not connected, a groupoid morphism from G to H is a union of a list `mors` of morphisms of connected groupoids.

There are two ways of combining `m1 : G1->H1` and `m2 : G2->H2` into a single morphism. The operation `GroupoidMorphismByUnion( [m1,m2] );` constucts the groupoid unions `G12,H12` of `G1` with `G2` and `H1` with `H2`, and then a morphism `m12 : G12->H12`. If `G12,H12` have already been constructed, the operation `GroupoidMorphismByComponents( G12, H12, [m1,m2] );` may be more appropriate.

    gap> imad8 := [ (1,2,3,4), (2,4) ];;
    gap> ad8 := GroupHomomorphismByImages( d8, d8, [(1,2,3,4),(1,3)], imad8 );;
    gap> aGd8 := MorphismOfConnectedGroupoids( Gd8, Gd8, [-8,-7,-9], ad8 );;
    gap> mor1 := GroupoidMorphismByUnion( [ aGd8, mc6 ] );;
    gap> mor2 := GroupoidMorphismByComponents( Gd8c6, Gs3dd8, [ aGd8, mc6 ] );;
    gap> Display( mor2 );
    Groupoid Morphism: Gd8+Gc6 -> Gs3d+Gd8 with components :
    [ Gc6 ] -> [ Gs3d ]
      object map = [ [ -6 ], [ -36 ] ]
    homomorphism = [ [ (5,6,7)(8,9) ], [ (15,19)(16,18) ] ]
    [ Gd8 ] -> [ Gd8 ]
      object map = [ [ -9, -8, -7 ], [ -8, -7, -9 ] ]
    homomorphism = [ [ (1,2,3,4), (1,3) ], [ (1,2,3,4), (2,4) ] ]
    gap> mor1 = mor2;
    true

##### 3.2-2 IsGroupoidMorphism

`> IsGroupoidMorphism`( mor ) | ( property )

`> IsInjectiveOnObjects`( mor ) | ( property )

`> IsSurjectiveOnObjects`( mor ) | ( property )

`> IsBijectiveOnObjects`( mor ) | ( property )

`> IsGroupoidAutomorphism`( mor ) | ( property )

Here are some of the basic properties of groupoid morphisms.

    gap> IsGroupoidMorphism( res );
    true
    gap> IsInjectiveOnObjects( res );
    true
    gap> IsInjective( res );
    false
    gap> IsSurjectiveOnObjects( inc );
    true
    gap> IsSurjective( inc );
    false
    gap> IsGroupoidAutomorphism( aGd8 );
    true
    gap> eGd8 := MorphismOfConnectedGroupoids( Gd8, Gd8, [-7,-7,-9], ad8 );;
    gap> IsGroupoidEndomorphism( eGd8 );
    true

##### 3.2-3 ImagesOfObjects

`> ImagesOfObjects`( mor ) | ( attribute )

`> ImagesSource`( mor ) | ( attribute )

`> ImageElm`( mor, elt ) | ( operation )

Here are some of examples of operations that return images. These are not yet fully implemented: for example, `ImageElm` and `ImagesSource` require the range of `mor` to be connected.

    gap> ImagesOfObjects( md8 );
    [ [ -34, -35, -36, -36 ] ]
    gap> ImagesSource(md8);
    Perm Connected Groupoid:
    < [ -36, -35, -34 ], Group( [ (), (15,20)(16,19)(17,18) ] ) >
    gap> e1;
    [(1,2)(3,4) : -9 -> -8]
    gap> ImageElm( md8c6, e1 );
    [(15,20)(16,19)(17,18) : -34 -> -35]

##### 3.2-4 Product

`> Product`( mors ) | ( operation )

Morphisms m_1, m_2 can be composed if the image of m_1 is contained in the domain of m_2. Currently composition is only defined for morphisms of connected groupoids.

    gap> Hk4d := SubgroupoidByComponents( Gd8, [ [[-9,-8,-7], k4d] ] );;
    gap> genq8 := GeneratorsOfGroup(q8);;
    gap> hq8 := GroupHomomorphismByImages( q8,k4d,genq8,[(1,2)(3,4),(1,3)(2,4),()]);;
    gap> mq8 := GroupoidMorphism( Gq8, Hk4d, [-7,-9], hq8 );;
    gap> iHk4d := InclusionMappingGroupoids( Gd8, Hk4d );;
    gap> mor3 := mq8*iHk4d;;
    gap> Display( mor3 );
    Morphism to connected groupoid:
    [ Gq8 ] -> [ Gd8 ]
      object map = [ [ -28, -27 ], [ -7, -9 ] ]
    homomorphism = [ Pcgs([ f1, f2, f3 ]), [ (1,2)(3,4), (1,3)(2,4), () ] ]
    gap> mor4 := mor1*aGd8;;
    gap> Display( mor4 );
    Morphism to connected groupoid:
    [ Gq8 ] -> [ Gd8 ]
      object map = [ [ -28, -27 ], [ -9, -8 ] ]
    homomorphism = [ Pcgs([ f1, f2, f3 ]), [ (1,4)(2,3), (1,3)(2,4), () ] ]

##### 3.2-5 InverseMorphism

`> InverseMorphism`( mor ) | ( attribute )

`> Order`( mor ) | ( attribute )

The inverse of a morphism m is defined when m is bijective on objects and on elements. The operation `InverseMorphism` is a synonym for `InverseGeneralMapping`. The order of an automorphism is the smallest power which returns the identity morphism of G.

    gap> genq8 := GeneratorsOfGroup( q8 );;
    gap> imq8 := [ q8.2, q8.1*q8.2, q8.3 ];
    [ f2, f1*f2, f3 ]
    gap> autq8 := GroupHomomorphismByImages( q8, q8, genq8, imq8 );;
    gap> autGq8 := GroupoidMorphism( Gq8, Gq8, [-27,-28], autq8 );;
    gap> Display( InverseMorphism( autGq8 ) );
    Morphism to connected groupoid:
    [ Gq8 ] -> [ Gq8 ]
      object map = [ [ -28, -27 ], [ -27, -28 ] ]
    homomorphism = [ [ f2, f1*f2, f3 ], [ f1, f2, f3 ] ]
    gap> Order( autGq8 );
    6

Top of Book | Previous Chapter | Next Chapter

Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | Bib | Ind

generated by GAPDoc2HTML