[MathJax on]
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
‣ IsRightQuasigroupHomomorphism ( f ) | ( operation ) |
‣ IsQuasigroupHomomorphism ( f ) | ( operation ) |
‣ IsLoopHomomorphism ( f ) | ( operation ) |
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
‣ IsRightQuasigroupIsomorphism ( f ) | ( operation ) |
‣ IsQuasigroupIsomorphism ( f ) | ( operation ) |
‣ IsLoopIsomorphism ( f ) | ( operation ) |
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
‣ IsRightQuasigroupEndomorphism ( f ) | ( operation ) |
‣ IsQuasigroupEndomorphism ( f ) | ( operation ) |
‣ IsLoopEndomorphism ( f ) | ( operation ) |
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
‣ IsRightQuasigroupAutomorphism ( f ) | ( operation ) |
‣ IsQuasigroupAutomorphism ( f ) | ( operation ) |
‣ IsLoopAutomorphism ( f ) | ( operation ) |
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
‣ RightQuasigroupHomomorphismByImages ( Q1, Q2[[, gens], imgs] ) | ( operation ) |
‣ QuasigroupHomomorphismByImages ( Q1, Q2[[, gens], imgs] ) | ( operation ) |
‣ LoopHomomorphismByImages ( Q1, Q2[[, gens], imgs] ) | ( operation ) |
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
‣ KernelRelationOfMapping ( f ) | ( operation ) |
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
‣ KernelOfLoopHomomorphism ( f ) | ( operation ) |
‣ KernelOfLoopHomomorphismNC ( f ) | ( operation ) |
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
‣ NaturalHomomorphismByCongruence ( C ) | ( operation ) |
‣ NaturalHomomorphismByCongruenceNC ( C ) | ( operation ) |
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
‣ NaturalHomomorphismByNormalSubloop ( Q, S ) | ( operation ) |
‣ NaturalHomomorphismByNormalSubloopNC ( Q, S ) | ( operation ) |
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
‣ RightQuasigroupIsomorph ( [Q, ]f[, isCanonical, constructorStyle] ) | ( function ) |
‣ QuasigroupIsomorph ( [Q, ]f[, isCanonical, constructorStyle] ) | ( function ) |
‣ LoopIsomorph ( [Q, ]f[, isCanonical, constructorStyle] ) | ( function ) |
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
‣ IsomorphismDiscriminator ( Q ) | ( attribute ) |
Returns: a data structure suitable for isomorphism searches from a right quasigroup Q
.
8.3-2 AreEqualIsomorphismDiscriminators
‣ AreEqualIsomorphismDiscriminators ( dis1, dis2 ) | ( operation ) |
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
‣ IsomorphismRightQuasigroups ( Q1, Q2 ) | ( operation ) |
‣ IsomorphismQuasigroups ( Q1, Q2 ) | ( operation ) |
‣ IsomorphismLoops ( Q1, Q2 ) | ( operation ) |
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
‣ RightQuasigroupsUpToIsomorphism ( ls ) | ( operation ) |
‣ QuasigroupsUpToIsomorphism ( ls ) | ( operation ) |
‣ LoopsUpToIsomorphism ( ls ) | ( operation ) |
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
‣ AutomorphismGroup ( Q ) | ( attribute ) |
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) ])