[MathJax off]

8 Homomorphisms, isomorphisms and automorphisms

8.1 Homomorphisms, isomorphisms and automorphisms of right quasigroups

A mapping \(f:(Q_1,\cdot)\to (Q_2,*)\) between (right) quasigroups is a homomorphism if \(f(x)*f(y) = f(x\cdot y)\) for every \(x,y\in Q_1\). The homomorphism \(f\) then automatically preserves divisons. If \(f\) is also a bijection, it is an isomorphism. If \((Q_1,\cdot)=(Q_2,*)\) then \(f\) is an endomorphism. A bijective endomorphism is an automorphism.

In RightQuasigroups, homomorphisms and isomorphisms are represented as right quasigroup mappings, while automorphisms are represented as parent permutations. See Chapter 4 for conversions between right quasigroup mappings, permutations and transformations.

8.1-1 Testing homomorphisms

Returns: true if the mapping f is a homomorphism of right quasigroups (quasigroups, loops), else returns false. The function checks that the source and range of f are right quasigroups (quasigroups, loops) and that f respects multiplication.

8.1-2 Testing isomorphisms

Returns: true if the mapping f is an isomorphism of right quasigroups (quasigroups, loops), else returns false. The function checks f is a bijective right quasigroup (quasigroup, loop) homomorphism.

Mappings returned by IsomorphismRightQuasigroups are right quasigroup isomorphisms.

gap> A := QuasigroupByFunction( [0..7], function(x,y) return (x-y) mod 8; end );;
gap> B := QuasigroupByFunction( [0..3], function(x,y) return (x-y) mod 4; end );;
gap> SetQuasigroupElementsName(B, "b" );;
gap> f := function( x ) return B[ UnderlyingSetElm( x ) mod 4 ]; end;; 
gap> List( A, f );
[ b0, b1, b2, b3, b0, b1, b2, b3 ]
gap> m := MappingByFunction( A, B, f );;
gap> IsRightQuasigroupHomomorphism( m );
true
gap> IsRightQuasigroupIsomorphism( m );
false
gap> IsSurjective( m );
true

8.1-3 Testing endomorphisms

Returns: true if the mapping f is an endomorphism of a right quasigroup (quasigroup, loop), else returns false. The function checks that f is a right quasigroup (quasigroup, loop) homomorphism with identical source and range.

8.1-4 Testing automorphisms

Returns: true if the mapping f is an automorphism of a right quasigroup (quasigroup, loop), else returns false. The function checks that f is a bijective right quasigroup (quasigroup, loop) endomorphism.

Note that elements of automorphism groups of right quasigroups are not right quasigroup automorphisms in this sense and must be converted via AsRightQuasigroupMapping.

gap> Q := AutomorphicLoop( 15, 1 );;
gap> f := LeftInnerMapping( Q, Q.6, Q.2 );
(6,9,8,7,10)(11,15,12,13,14)
gap> m := AsRightQuasigroupMapping( Q, f );;
gap> IsRightQuasigroupAutomorphism( m );
true

8.1-5 Homomorphisms by images

Returns: the homomorphism from right quasigroup (quasigroup, loop) Q1 to right quasigroup (quasigroup, loop) Q2 determined by the images imgs on the generators gens of Q1. If the list gens is omitted, GeneratorsOfRightQuasigroup(Q1) is used instead. If the list imgs is omitted, GeneratorsOfRightQuasigroup(Q2) is used instead. If gens, imgs are not of the same length, error is returned. If gens does not generate Q1, fail is returned. If the arguments do not define a homomorphism, fail is returned.

gap> Q := CheinLoop( SymmetricGroup( 3 ) );;
gap> gens := SmallGeneratingSet( Q ); # also sets GeneratorsOfMagma in this case
[ l[ 0, (2,3) ], l[ 0, (1,2,3) ], l[ 1, () ] ]
gap> S := AsLoop( Group((1,2)) );;
gap> f := LoopHomomorphismByImages( Q, S, gens, [ S[()],S[()],S[(1,2)] ] );
MappingByFunction( <Moufang loop of size 12>, <associative loop of siz\
e 2>, function( x ) ... end )
gap> Q[ [1,(1,2,3)] ]^f;
l(1,2)

8.1-6 KernelRelationOfMapping

Returns: the kernel relation of the mapping f, that is, the equivalence relation E on Source( f ) such that xEy iff x^f = y^f.

gap> G := SymmetricGroup( 3 );;
gap> f := MappingByFunction( G, Domain([1,-1]), SignPerm );;
gap> ker := KernelRelationOfMapping( f );
<equivalence relation on SymmetricGroup( [ 1 .. 3 ] ) >
gap> EquivalenceClasses( ker );
[ {(2,3)}, {()} ]

8.1-7 Kernel of loop homomorphisms

Returns: the kernel of the loop homomorphism f, that is, the subloop of the loop Source( f ) consisting of all elements x such that x^f is the identity element of the loop Range( f ). The NC version does not check whether f is a loop homomorphism.

8.1-8 Natural homomorphism by congruence

Returns: the natural projection corresponding to the right quasigroup congruence C. With Q = Source( C ), it returns the endomorphism f from Q to Q/C such that x^f is the element of Q/C containing x (as a congruence class). The NC version does not check whether C is a congruence.

gap> Q := QuasigroupByFunction( [0..3], function(x,y) return (x-y) mod 4; end );;
gap> C := EquivalenceRelationByPartition( Q, [ [Q[0],Q[2]], [Q[1],Q[3]] ] );;
gap> f := NaturalHomomorphismByCongruence( C );
MappingByFunction( <quasigroup of size 4>, <quasigroup of size 2>, fun\
ction( x ) ... end )
gap> UnderlyingSet( Range( f ) );
[ {q0}, {q1} ]

8.1-9 Natural homomorphism by normal subloop

Returns: the natural projection from the loop Q to the factor loop Q/S. The NC version does not check whether S is a normal subloop of Q.

gap> Q := MoufangLoop( 12, 1 );
MoufangLoop( 12, 1 )
gap> f := NaturalHomomorphismByNormalSubloop( Q, Subloop(Q, [Q.2,Q.3] ) );
MappingByFunction( MoufangLoop( 12, 1 ), <Moufang loop of size 2>, fun\
ction( x ) ... end )

8.2 Isomorphs of right quasigroups

If \(f:(Q,\cdot)\to (Q,*)\) is an isomorphism, then \(x*y = f(f^{-1}(x)\cdot f^{-1}(y))\) for all \(x,y\in Q\), and \((Q,*)\) is called an isomorph of \((Q,\cdot)\) via \(f\).

For the convenience of the reader, functions that construct isomorphs accept a wide variety of arguments representing mappings:

• The argument f is mandatory and can be given as a bijective right quasigroup mapping, a bijective transformation or a permutation.

• If f is given as a transformation/permutation, the argument Q is also required, and it must be a right quasigroup, quasigroup or loop. The returned algebra will have the same underlying set as Q. If f is given as a right quasigroup mapping, its source will be used as Q.

• Any subset of the two optional arguments isCanonical and constructorStyle can be given.

• If the optional argument isCanonical is given and set to true, the permutation/transformation f is interpreted as a canonical permutation/transformation, else it is by default interpreted as parent permutation/transformation. (See Chapter 4.)

• See Section 2.1 for the optional argument constructorStyle.

8.2-1 Isomorphs

Returns: the isomorph of the right quasigroup (quasigroup, loop) Q via f. See above for conventions on the arguments. An effort is made for the isomorph to inherit properties from Q.

gap> Q1 := MoufangLoop( 12, 1 );
MoufangLoop( 12, 1 )
gap> Q2 := LoopIsomorph( Q1, (3,4,5) ); # Other kinds of mappings are accepted. Note inherited properties.
<Moufang loop of size 12>

8.3 Right quasigroups up to isomorphisms

To decide if two right quasigroups are isomorphic, RightQuasigroups first calculates some isomorphism invariants and a partition invariant under isomorphisms, and then determines if there is an isomorphisms that respects the partition.

8.3-1 IsomorphismDiscriminator

Returns: a data structure suitable for isomorphism searches from a right quasigroup Q.

8.3-2 AreEqualIsomorphismDiscriminators

Returns: true if the two isomorphism discriminators dis1, dis2 (each returned by IsomorphismDiscriminator) are equal as discriminators, else returns false. If false is returned, the two disriminators correspond to right quasigroups that are not isomorphic. If true is returned, the corresponding right quasigroups might be isomorphic.

8.3-3 IsomorphismRightQuasigroups, IsomorphismQuasigroups, IsomorphismLoops

Returns: an isomorphism between the right quasigroups (quasigroups, loops) Q1 and Q2, if one exists, else returns fail. If an isomorphism from Q1 to Q2 exists, it is returned as a right quasigroup mapping. See Chapter 4 for conversion options of the returned mapping.

gap> Q1 := RightQuasigroupByFunction( [0..9], function(x,y) return (x+2*y) mod 10; end );
<right quasigroup of size 10>
gap> Q2 := RightQuasigroupIsomorph( Q1, (3,4,5) );
<right quasigroup of size 10>
gap> IsomorphismRightQuasigroups( Q1, Q2 );
MappingByFunction( <right quasigroup of size 10>, <right quasigroup of\
 size 10>, function( x ) ... end )
gap> AsCanonicalTransformation( last );
Transformation( [ 1, 2, 4, 5, 3 ] )
gap> AsPermutation( last );
(3,4,5)

8.3-4 Right quasigroups up to isomorphism

Returns: a sublist of ls consisting of all right quasigroups (quasigroups, loops) in ls up to isomorphism. Via an optional parameter :UseDiscriminator one may force the algorithm to use IsomorphismDiscriminator as an invariant to speed up isomorph rejection.

gap> Q1 := CheinLoop( SymmetricGroup( 3 ) );;
gap> Q2 := LoopIsomorph( Q1, (1,2) );;
gap> Q3 := AsLoop( CyclicGroup( 12 ) );;
gap> lps := LoopsUpToIsomorphism( [ Q1, Q2, Q3 ] );
[ <Moufang loop of size 12>, <associative loop of size 12> ]
gap> lps[1] = Q1; lps[2] = Q3;
true
true
gap> 
gap> g := TransitiveGroup( 8, 31 );
[2^4]E(4)
gap> lps := AllLoopsWithMltInGroup( g, 2, 0 );; Size( lps );
192
gap> Apply( lps, LoopByRightSection );
gap> Size( LoopsUpToIsomorphism( lps : UseDiscriminator ) );
58

8.4 Automorphism groups of right quasigroups

8.4-1 AutomorphismGroup

Returns: the automorphism group of the right quasigroup Q as a subgroup of the symmetric group on [1..Size(Parent(Q))].

gap> Q := MoufangLoop( 12, 1 );
MoufangLoop( 12, 1 )
gap> ag := AutomorphismGroup( Q );; IdGroup( ag );
[ 108, 17 ]
gap> S := Subloop( Q, [Q.3] );; ParentInd( S );
[ 1, 3, 5 ]
gap> AutomorphismGroup( S ); # consists of parent permutations
Group([ (3,5) ])

generated by GAPDoc2HTML