A triple of mappings t = (f,g,h):(Q_1,\cdot)\to (Q_2,*) between right quasigroups is a homotopism if f(x)*g(y) = h(x\cdot y) for every x,y\in Q_1. The right quasigroup Q_1 is the source of t, Q_2 is the range of t, and the mappings f, g, h are the components of t. If f, g, h are also bijections, t is an isotopism. An isotopism with (Q_1,\cdot) = (Q_2,*) is an autotopism.
‣ IsRightQuasigroupHomotopism( object ) | ( filter ) |
Returns: true or false.
In RightQuasigroups, homotopisms are represented by a GAP category IsRightQuasigroupHomotopism that stores attributes and whose objects can be multiplied and inverted. Homotopisms keep track of the source, the range, and the three mappings. If the source is equal to the range, the mappins are stored as parent permutations, otherwise they are stored as parent transformations.
‣ Source( t ) | ( attribute ) |
‣ Range( t ) | ( attribute ) |
‣ ComponentOfHomotopism( t, i ) | ( operation ) |
Returns: the source, range and the ith component of a homotopism t, respectively. The attributes can be also accessed directly via t!.source, t!.range, t!.f, t!.g and t!.h.
The three components are stored as parent transformations or as parent permutations (when the source equals the range).
‣ IsInjective( t ) | ( property ) |
‣ IsSurjective( t ) | ( property ) |
‣ IsBijective( t ) | ( property ) |
Returns: true or false
Returns true if (every component of) the homotopism t is injective, surjective and bijective, respectively.
‣ HomotopismRightQuasigroups( Q1, Q2, f, g, h[, isCanonical] ) | ( operation ) |
Returns: a homotopism from right quasigroup Q1 to right quasigroup Q2 according to the three mappings f, g, h. Each of the mappings can be a right quasigroup mappings (with source Q1 and range Q2), or a transformation, or a permutation (where the latter only makes sense if Q1 equals Q2). If the optional argument isCanonical is set to true, all transformations/permutations are understood as canonical (not parent) transformations/permutations. The function performs an explicit check that the provided data give rise to a homotopism.
We also support other formats of the arguments, namely HomotopismRightQuasigroups( Q, f, g, h[, isCanonical]) when Q is both the source and the range, and HomotopismRightQuasigroups( f, g, h ) when the three mappings are right quasigroup mappings (which keep track of the source and the range). Note that in the last format the optional argument isCanonical is not supported because it is meaningless.
Here is an example of a constructor for a homotopism:
gap> Q1 := ProjectionRightQuasigroup( 3 );; gap> Q2 := ProjectionRightQuasigroup( 2 );; gap> f := Transformation( [1,1,2] );; g := Transformation( [2,1,2] );; h := f;; gap> t := HomotopismRightQuasigroups( Q1, Q2, f, g, h ); <homotopism of right quasigroups> gap> IsRightQuasigroupHomotopism( t ); # category/filter check true gap> Display( t ); <homotopism of right quasigroups source = <associative quandle of size 3> range = <associative quandle of size 2> f = Transformation( [ 1, 1, 2 ] ) g = Transformation( [ 2, 1, 2 ] ) h = Transformation( [ 1, 1, 2 ] ) > gap> [ Source( t ), Range( t ) ]; [ <associative quandle of size 3>, <associative quandle of size 2> ] gap> ComponentOfHomotopism( t, 2 ); # the second component, g Transformation( [ 2, 1, 2 ] )
And here is an example of a constructor for a homotopism with the same source and range. The homotopism is immediately recognized to be an autotopism since the three given mappings are permutations.
gap> Q := QuasigroupByFunction( [0..4], function( x,y ) return (x+y) mod 5; end );; gap> f := (1,2,3,4,5);; g := (2,4,1,3,5);; h := (3,1,4,2,5);; # +1, +2, +3 gap> t := HomotopismRightQuasigroups( Q, f, g, h ); <autotopism of quasigroups> gap> Display( t ); <autotopism of quasigroups source = range = <quasigroup of size 5> f = (1,2,3,4,5) g = (1,3,5,2,4) h = (1,4,2,5,3) >
‣ AutotopismRightQuasigroup( Q, f, g, h[, isCanonical] ) | ( function ) |
Returns: an autotopism of a right quasigroup Q according to the three bijections f, g, h. The function differs from HomotopismRightQuasigroups( Q, f, g, h ) in that it explicitly checks that the provided mappings are bijective. The format of the mappings and the optional argument isCanonical behave as for HomotopismRightQuasigroups.
‣ IdentityAutotopism( Q ) | ( operation ) |
Returns: the identity autotopism on the right quasigroup Q. The identity autotopism can also be obtained by calling HomotopismRightQuasigroups( Q, (), (), () ). Finally, given any homotopism t with source Q, the method One( t ) returns the identity autotopism on Q.
Homotopism can be compared, multiplied (composed from left to right) and inverted (if they are bijective).
gap> Q := QuasigroupByFunction( [0..4], function( x, y ) return (x+y) mod 5; end );; gap> f := RightTranslation( Q, 1 );; g := LeftTranslation( Q, 2 );; h := RightTranslation( Q, 3 );; gap> t := HomotopismRightQuasigroups( Q, f, g, h );; gap> Display( t*t ); <autotopism of quasigroups source = range = <quasigroup of size 5> f = (1,3,5,2,4) g = (1,5,4,3,2) h = (1,2,3,4,5) > gap> Display( t^-1 ); <autotopism of quasigroups source = range = <quasigroup of size 5> f = (1,5,4,3,2) g = (1,4,2,5,3) h = (1,3,5,2,4) > gap> One( t ); <identity autotopism> gap> Display( last ); <identity autotopism on <quasigroup of size 5>>
‣ IsHomotopismRightQuasigroups( Q1, Q2, f, g, h[, isCanonical] ) | ( function ) |
‣ IsHomotopismQuasigroups( Q1, Q2, f, g, h[, isCanonical] ) | ( function ) |
‣ IsHomotopismLoops( Q1, Q2, f, g, h[, isCanonical] ) | ( function ) |
Returns: true if the data provided in the arguments gives rise to a homotopism of right quasigroups (quasigroups, loops). Accepts the same type of arguments as the constructor HomotopismRightQuasigroups.
‣ IsIsotopismRightQuasigroups( Q1, Q2, f, g, h[, isCanonical] ) | ( function ) |
‣ IsIsotopismQuasigroups( Q1, Q2, f, g, h[, isCanonical] ) | ( function ) |
‣ IsIsotopismLoops( Q1, Q2, f, g, h[, isCanonical] ) | ( function ) |
Returns: true if the data provided by in the arguments gives rise to an isotopism of right quasigroups (quasigroups, loops). Accepts the same type of arguments as the constructor HomotopismRightQuasigroups.
‣ IsAutotopismRightQuasigroups( Q, f, g, h[, isCanonical] ) | ( function ) |
‣ IsAutotopismQuasigroups( Q, f, g, h[, isCanonical] ) | ( function ) |
‣ IsAutotopismLoops( Q, f, g, h[, isCanonical] ) | ( function ) |
Returns: true if the data provided by in the arguments gives rise to an isotopism of right quasigroups (quasigroups, loops). Accepts the same type of arguments as the constructor HomotopismRightQuasigroups with the same source and range.
In this section we introduce a natural construction that encompasses isomorphs, isotopes and affine constructions as special cases.
Given a magma Q and three mappings f,g,h:Q\to Q, the twist \mathrm{Tw}(Q,f,g,h) of Q via (f,g,h) is defined to be the magma (Q,*) with multiplication x*y = h(f(x)g(y)).
If Q is a right quasigroup, the twist \mathrm{Tw}(Q,f,g,h) is a right quasigroup iff both f and h are bijections of Q. Moreover, the twist \mathrm{Tw}(Q,f,g,h) is a quasigroup iff all three f, g and h are bijections of Q. Finally, if \mathrm{Tw}(Q,f,g,h) is a quasigroup then it is a loop iff g^{-1}(f(x)\backslash h^{-1}(x)) is equal to f^{-1}(h^{-1}(x)/g(x)) and independent of x.
For the convenience of the reader, functions that work with twists accept a wide variety of arguments representing mappings. The conventions on arguments here are analogous to those for isomorphs, cf. Section 8.2. In more detail:
The functions are named according to the type of algebra they return, not according to the type of algebra they require as input. For instance, LoopTwist returns a loop but it accepts a quasigroup (or loop).
The arguments f, g, h are mandatory and each can be given as a right quasigroup mapping, a transformation or a permutation. The arguments f and h must always give rise to bijections. If a quasigroup is supposed to be returned, then also g must give rise to a bijection. Finally, if a loop is supposed to be returned then g^{-1}(f(x)\backslash h^{-1}(x)) must be equal to f^{-1}(h^{-1}(x)/g(x)) and independent of x.
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.
‣ RightQuasigroupTwist( [Q, ]f, g, h[, isCanonical, constructorStyle] ) | ( function ) |
‣ QuasigroupTwist( [Q, ]f, g, h[, isCanonical, constructorStyle] ) | ( function ) |
‣ LoopTwist( [Q, ]f, g, h[, isCanonical, constructorStyle] ) | ( function ) |
Returns: the twist of the right quasigroup Q via f, g, h, that is, the right quasigroup (quasigroup, loop) on the underlying set of Q with multiplication x*y = h(f(x)g(y)). See above for conventions on the arguments.
gap> Q := MoufangLoop( 12, 1 );; gap> f := (1,2,3);; g := Transformation( [3,3,3] );; h := MappingByFunction( Q, Q, x->x^-1 );; # note various formats gap> T := RightQuasigroupTwist( Q, f, g, h ); # f and h must be bijective <right quasigroup of size 12> gap> QuasigroupTwist( Q, f, (1,12), h ); # g must be bijective for quasigroups <quasigroup of size 12> gap> f := RightTranslation( Q, Q.2 )^-1;; g := LeftTranslation( Q, Q.3 )^-1;; gap> LoopTwist( Q, f, g, (), ConstructorStyle( true, true ) ); # principal loop isotope <loop of size 12>
If t=(f,g,h):(Q,\cdot)\to (Q,*) is an isotopism, then x*y = h(f^{-1}(x)\cdot g^{-1}(y)) for all x,y\in Q, and (Q,*) is called an isotope of (Q,\cdot) via f, g, h. (Note that isotopes are special cases of twists, as introduced in Section 9.2.) The isotope (Q,*) is a (right) quasigroup iff (Q,\cdot) is a (right) quasigroup, but an isotope of a loop might not be a loop.
Given a quasigroup (Q,\cdot,/,\backslash) and a,b\in Q, the principal loop isotope via a,b is defined as (Q,\circ), where x\circ y = (x/a)\cdot(b\backslash y). The principal loop isotope is automatically a loop with neutral element b\cdot a.
‣ RightQuasigroupIsotope( [Q, ]f, g, h[, isCanonical, constructorStyle] ) | ( function ) |
Returns: the isotope of the right quasigroup Q via isotopism f, g, h, that is, the right quasigroup on the underlying set of Q with multiplication x*y = h(f^{-1}(x)g^{-1}(y)). See Section 9.2 for conventions on the arguments.
‣ QuasigroupIsotope( [Q, ]f, g, h[, isCanonical, constructorStyle] ) | ( function ) |
Returns: the isotope of the quasigroup Q via isotopism f, g, h, that is, the quasigroup on the underlying set of Q with multiplication x*y = h(f^{-1}(x)g^{-1}(y)). See Section 9.2 for conventions on the arguments.
‣ LoopIsotope( [Q, ]f, g, h[, isCanonical, constructorStyle] ) | ( function ) |
Returns: the loop isotope of the quasigroup Q via isotopism f, g, h, that is, the loop on the underlying set of Q with multiplication x*y = h(f^{-1}(x)g^{-1}(y)). See Section 9.2 for conventions on the arguments.
Warning: Unless the constructor style specifies that arguments should be checked, they will not be checked and the returned algebra might not have an identity element despite being declared a loop.
gap> style := ConstructorStyle( false, false );; gap> P := QuasigroupByFunction( [0..99999], function(x,y) return (x-y) mod 10^5; end, style ); <quasigroup of size 100000> gap> f := (1,10,100,1000,10000,100000);; g := (3,4);; h := ();; gap> R := QuasigroupIsotope( P, f, g, h, style ); <quasigroup of size 100000> gap> R.1000*R.4; q97
‣ PrincipalLoopIsotope( Q, a, b ) | ( operation ) |
Returns: the loop isotope of the quasigroup Q via its elements a, b. The resulting loop has the same underlying set as Q and its neutral element corresponds to b*a.
gap> Q := QuasigroupByFunction( GF(11), \- );; gap> P := PrincipalLoopIsotope( Q, Q.3, Q.4 ); <loop of size 11> gap> UnderlyingSetElm( Q.4*Q.3 ) = UnderlyingSetElm( One( P ) ); true
Let Q be a loop, let f,g be endomorphisms of Q and u,v\in Q. Define a new multiplication * on Q by x*y = (f(x)u)(g(y)v) and denote the resulting magma by \mathrm{Aff}(Q,f,u,g,v). Then \mathrm{Aff}(Q,f,u,g,v) is a right quasigroup iff f is an automorphism of Q and it is a quasigroup iff both f and g are automorphisms of Q. Analogous comments hold for \mathrm{Aff}(Q,f,u,v,g), \mathrm{Aff}(Q,u,f,g,v) and \mathrm{Aff}(Q,u,f,v,g), where the multiplication formula is obtained according to the order of the arguments. For instance, in \mathrm{Aff}(Q,u,f,g,v) the multiplication is given by x*y = (uf(x))(g(y)v).
Any such (right) quasigroup is said to be affine over the loop Q and the parameters constitute its arithmetic form .
Note that affine right quasigroups are instances of twists of right quasigroups, cf. Section 9.2. Also note that if Q is an abelian group then all four formulas reduce to x*y = f(x)g(y)uv, and we can replace u, v with a single element c.
Several different formats of arithmetic forms are supported in RightQuasigroups:
(n,f,g,c) for four integers such that n is positive, Gcd(n,f)=1 (and Gcd(n,g)=1 for quasigroups). The multiplication is then defined on [0..n-1] by (f*x + g*y +c) mod n.
(F,f,g,c), where F is a field, f is a nonzero element of F and g, c are elements of F (and g is nonzero for quasigroups). The multiplication is then defined on F by f*x + g*y +c.
(G,f,g,c), where G is an abelian group or an abelian additive group, f is an automorphism of G, g is an endomorphism of G, and c is an element of G (and g is bijective for quasigroups). The multiplication is then defined on G by x^f+y^g+c if G is an additive group and by x^f*y^g*c otherwise.
(G,f,u,g,v), where G is a loop, a group, or an additive group, f is an automorphisms of G, g is an endomorphisms of G and u, v are elements of G (and g is bijective for quasigroups). The multiplication is then defined on G by (x^f+u)+(y^g+v) in the additive case and by (x^f*u)*(y^g*v) otherwise.
The three variations (G,f,u,v,g), (G,u,f,g,v) and (G,u,f,v,g) are also supported.
‣ IsAffineRightQuasigroupArithmeticForm( arg ) | ( function ) |
Returns: true if the arguments constitute an arithmetic form for an affine right quasigroup, else returns false. See above for the possible formats of arithmetic forms.
‣ IsAffineQuasigroupArithmeticForm( arg ) | ( function ) |
Returns: true if the arguments constitute an arithmetic form for an affine quasigroup, else returns false. See above for the possible formats of arithmetic forms.
‣ AffineRightQuasigroup( arg[, constructorStyle] ) | ( function ) |
Returns: the affine right quasigroup by the arithmetic form arg. See above for the possible formats of arithmetic forms. If a loop G is part of the arithmetic form, the right quasigroup is returned as an isotope of G. In all other cases the code first internally creates a suitble right quasigroup Gand then returns an isotope of Q.
‣ AffineQuasigroup( arg[, constructorStyle] ) | ( function ) |
Returns: the affine quasigroup by the arithmetic form arg. See above for the possible formats of arithmetic forms. Also see the remark on isotopy under AffineRightQuasigroup.
Here are four examples of affine (right) quasigroups, constructed from various arithmetic forms. First over ([0..n-1],+):
gap> IsAffineRightQuasigroupArithmeticForm( 10, 3, 5, 1 ); # suitable for (3*x+5*y+1) mod 10 true gap> IsAffineQuasigroupArithmeticForm( 10, 3, 5, 1 ); # gcd(10,5) <> 1 false gap> Q := AffineRightQuasigroup( 10, 3, 5, 1 ); <right quasigroup of size 10> gap> Q := AffineRightQuasigroup( 100000, 333, 777, 5, ConstructorStyle(false,false) ); # non-index based example <right quasigroup of size 100000>
Next over a finite field:
gap> F := GF(9);; f := Z(9);; g := Z(9)^3;; c := Z(9)^5;; gap> IsAffineQuasigroupArithmeticForm( F, f, g, c ); # suitable for f*x+g*y+c true gap> AffineQuasigroup( F, f, g, c ); <quasigroup of size 9>
Next over an abelian group:
gap> G := CyclicGroup(10);; A := AutomorphismGroup( G );; f := A.1;; g := A.2;; c := G.1;; gap> IsAffineQuasigroupArithmeticForm( G, f, g, c ); # suitable for x^f*y^g*c true gap> AffineQuasigroup( G, f, g, c ); <quasigroup of size 10>
Next over a group:
gap> G := DihedralGroup(12);; gap> f := MappingByFunction( G, G, x->x^(G.1) );; g := MappingByFunction( G, G, x->x^(G.2) );; u := G.1;; v := G.2;; gap> IsAffineQuasigroupArithmeticForm( G, f, u, g, v ); # suitable for (x^f*u)*(y^g*v) true gap> AffineQuasigroup( G, f, u, g, v ); <quasigroup of size 12>
And finally over a loop. Note that the left translations (which are parent permutations) must be converted into loop mappings in the example.
gap> G := AutomorphicLoop( 10, 1 );; # inner mappings are automorphisms here gap> f := AsRightQuasigroupMapping( G, LeftInnerMapping( G, G.2, G.3 ) );; gap> g := f*f;; u := G.1;; v := G.2;; gap> IsAffineQuasigroupArithmeticForm( G, u, f, v, g ); # suitable for (u*x^f)*(v*y^g) true gap> Q := AffineQuasigroup( G, u, f, v, g ); <quasigroup of size 10>
We support four methods for calculating isotopisms between loops, quasigroups and right quasigroups Q_1, Q_2:
"via perfect matchings with invariants" (default method for right quasigroups): considers all possible f that preserve certain invariants of right quasigroups, then completes the isotopism by finding a perfect matching in a bipartite graph,
"via perfect matchings with automorphism group": considers all possible f modulo the automorphism group of Q1, then employs perfect matchings as above,
"via domain extension" (for quasigroups and loops only, default method for quasigroups and loops): attempts to find an isotopism (f,g,h) by iteratively enlarging the domains of f, g and h,
"via principal loop isotopes" (for loops only): constructs principal loop isotopes of Q1 one by one and checks if any one of them is isomrphic to Q2.
‣ IsotopismDiscriminator( Q ) | ( attribute ) |
Returns: a certain invariant m of the right quasigroup Q that is preserved by isotopisms. (Strictly speaking, only the sorted version of m is preserved under isotopisms, see AreEqualIsotopismDscriminators.) In more detail, m is the list (m_x:x\in Q), m_x is the sorted list (m_{x,y}:y\in Q), and m_{x,y} is the number of occurrences of y in the row indexed by x.
gap> Q := RightQuasigroupByCayleyTable([[1,1,1],[2,3,2],[3,2,3]]);; gap> Display(IsotopismDiscriminator( Q ) ); [ [ 0, 0, 3 ], [ 0, 1, 2 ], [ 0, 1, 2 ] ]
‣ AreEqualIsotopismDiscriminators( D1, D2 ) | ( operation ) |
Returns: true when the two isotopism discriminators D1, D2 calculated via IsotopismDiscriminator are the same. When false is returned, it is guaranteed that the corresponding right quasigroups are not isotopic.
‣ ArePossiblyIsotopicRightQuasigroups( Q1, Q2 ) | ( operation ) |
Returns: false if the method determined that Q1, Q2 are not isotopic right quasigroups, based on their isotopism discrininators (and some additional invariants in the case of loops). When true is returned, the two right quasigroups might be isotopic.
‣ IsotopismRightQuasigroups( Q1, Q2[, method] ) | ( operation ) |
Returns: an isotopism from the right quasigroup Q1 onto the right quasigroup Q2, if it exists, else returns fail. The optional argument method must be set to one of the values "via perfect matchings with invariants", "via perfect matchings with automorphism group", "via domain extension" or "via principal loop isotopes". If no method is provided by the user, "via "via domain extension" for loops and quasigroups, while "via perfect matchings with invariants" for right quasigroups.
gap> Q1 := RandomRightQuasigroup( 30 );; gap> Q2 := RightQuasigroupIsotope( Q1, (1,2,3), (10,20,30), (4,30) );; gap> t := IsotopismRightQuasigroups( Q1, Q2 ); <isotopism of right quasigroups> gap> Q3 := RightQuasigroupIsotope( Q1, t!.f, t!.g, t!.h );; gap> MultiplicationTable( Q2 ) = MultiplicationTable( Q3 ); true
‣ IsotopismQuasigroups( Q1, Q2[, method] ) | ( operation ) |
Returns: an isotopism from the quasigroup Q1 onto the quasigroup Q2, if it exists, else returns fail. The only difference from IsotopismRightQuasigroups is that the arguments Q1, Q2 must be quasigroups.
‣ IsotopismLoops( Q1, Q2[, method] ) | ( operation ) |
Returns: an isotopism from the loop Q1 onto the loopp Q2, if it exists, else returns fail. The only difference from IsotopismRightQuasigroups is that the arguments Q1, Q2 must be loops.
gap> Q1 := MoufangLoop( 32, 10 ); MoufangLoop( 32, 10 ) gap> Q2 := LoopIsomorph( Q1, (3,4) );; gap> Q3 := PrincipalLoopIsotope( Q2, Q2.10, Q2.20 );; # a loop isotopic to Q1 gap> IsotopismLoops( Q1, Q3 ); <isotopism of loops>
‣ RightQuasigroupsUpToIsotopism( ls[, method] ) | ( operation ) |
‣ QuasigroupsUpToIsotopism( ls[, method] ) | ( operation ) |
‣ LoopsUpToIsotopism( ls[, method] ) | ( operation ) |
Returns: a sublist of ls consisting of all right quasigroups (quasigroups, loops) in ls up to isotopism. In case of loops, if the optional argument viaPrincipalLoopIsotopes is set to true, uses a method based on principal loop isotopes.
The autotopism group of a right quasigroup consist of abstract homotopism GAP objects. While the group operations are defined for them, the computation of size, center and other important group theoretical concepts is very slow. In this case, GAP recommends to use a NiceMonomorphism into a group G, whose representation allows fast generic methods. For autotopisms of a right quasigroup Q, G is the symmetric group on 3n points, where n is the size of the parent of Q. If the triple (f,g,h) defines an autotopism of Q, then its nice monomorphic image acts on \{1,\ldots,n\} as the parent permutation of f, on \{n+1,\ldots,2n\} as the conjugate of the parent permutation of g, and on \{2n+1,\ldots,3n\} as the conjugate of the parent permutation of h.
‣ RQ_NiceMonomorphism( t ) | ( function ) |
Returns: a permutation of degree 3n, where n is the size of the parent right quasigroup of the source of t.
The input is a HomotopismRightQuasigroups object. This map is a nice monomorphism for this category.
‣ RQ_NiceMonomorphismInverse( Q ) | ( function ) |
Returns: the inverse function f of the nice monomorphism HomotopismRightQuasigroups objects whose source is the right quasigroup Q. The function f maps permutations of degree 3n to isotopisms of Q, where n is the size of the parent of Q.
‣ RQ_AutotopismGroupByGeneratorsNC( Q, gens ) | ( operation ) |
Returns: a group consisting of HomotopismRightQuasigroups objects. This group has a a nice monomorphism to a permutation group of degree 3n where n is the order of the parent group of Q.
‣ AutotopismGroup( Q ) | ( attribute ) |
Returns: the autotopism group of a loop Q. Note: There is no generic method implemented yet for right quasigroups and quasigroups.
gap> q := RightBolLoop( 16, 3 ); RightBolLoop( 16, 3 ) gap> ag := AutotopismGroup( q ); <group with 5 generators> gap> Size( ag ); 768
Let (M,*) be a magma of order n, M=\{m_1,\ldots,m_n\}. Define the set T, which consists of triples \{i,j,k\}, 1\leq i \leq n < j \leq 2n < k \leq 3n, such that \{i,j,k\} \in T if and only if m_i*m_{j-n} = m_{k-2n}. Clearly, |T|=n^2. Define V=\{1,\ldots,3n\} \cup T and E=\{(i,t) : 1\leq i \leq 3n, i \in t\in T\}. Then \Gamma=(V,E) is a directed graph on 3n+n^2 vertices. We call \Gamma the digraph associated to M. If we define the color classes \{1,\ldots,n\}, \{n+1,\ldots,2n\}, \{2n+1,\ldots,3n\} and T on the vertices of \Gamma, then we speak of the colored digraph associated to M.
Two colored digraphs are isomorphic, if there is a bijection between their vertices, which preserves adjacency and colors. Two magmas are isotopic if and only if their associated colored digraphs are isomorphic. There is a one-to-one correspondance between autotopisms of a magma and the (color preserving) automorphisms of the associated colored digraph.
We use the BLISS interface of the Digraphs package to compute isomorphisms and automorphisms of colored digraphs. As a by-product of Brendon McKay's graph automorphism algorithm, we obtain a canonical labeling of \Gamma. Canonical labelings may speed up the search for isomorphisms between colored digraphs. However, canonical labeling of graphs are not uniquely defined, they may depend on the software version and the hardware specifications.
‣ RQ_Digraph( Q ) | ( attribute ) |
Returns: the colored directed graph on 3n+n^2 vertices, where n=|Q|.
‣ RQ_BlissCanonicalLabeling4Morphism( Q ) | ( attribute ) |
‣ RQ_BlissCanonicalLabeling4Topism( Q ) | ( attribute ) |
Returns: a permutation of degree n or 3n, where n=|Q|.
Let Q,S be two right quasigroups and u,v the permutations returned by RQ_BlissCanonicalLabeling4Morphism. Let Q' be the isomorph of Q via uv^{-1}. Then Q and S are isomorphic if and only if Q' and S have the same multiplication table. Similarly, let w,z be the permutations returned by RQ_BlissCanonicalLabeling4Topism. The map wz^{-1} induces three mappings g,f,h:Q\to S. Let Q' be the right quasigroup isotope of Q w.r.t. the mappings f,g,h. Then Q and S are isotopic if and only if Q' and S have the same multiplication table.
generated by GAPDoc2HTML