A rack is a right quasigroup satisfying the right self-distributive law \((x*y)*z = (x*z)*(y*z)\). A quandle is an idempotent rack.
A rack \(Q\) is homogeneous if its automorphism group acts transitively on \(Q\).
A rack \(Q\) is connected if its right multiplication group acts transitively on \(Q\).
A rack is latin if it is a quasigroup. A latin rack is automatically a (latin) quandle.
A latin rack is connected and a connected rack is homogeneous.
Constructors of RightQuasigroups declare racks and quandles as right quasigroups or, in the latin case, as quasigroups. If a rack/quandle is declared as a right quasigroup, it is displayed as <rack...> or <quandle...>, while if it is declared as a quasigroup, it is displayed as <latin rack...> or <latin quandle...>.
‣ IsRack( Q ) | ( property ) |
‣ IsQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a rack/quandle, else returns false.
‣ IsHomogeneousRack( Q ) | ( property ) |
‣ IsHomogeneousQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a homogeneous rack/quandle, that is, a rack/quandle on which the automorphism group acts transitively.
‣ IsConnectedRack( Q ) | ( property ) |
‣ IsConnectedQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a connected rack/quandle, that is, a rack/quandle on which the right multiplication group acts transitively.
‣ IsLatinRack( Q ) | ( property ) |
‣ IsLatinQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a latin rack/quandle, else returns false.
‣ IsProjectionRack( Q ) | ( property ) |
‣ IsProjectionQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a projection rack/quandle, that is, a rack/quandle satisfying \(x*y=x\).
‣ IsPermutationalRack( Q ) | ( property ) |
‣ IsPermutationalQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a permutational rack/quandle, that is, a rack/quandle satisfying \(x*y=f(x)\) for some permutation \(f\) of Q.
‣ IsFaithfulRack( Q ) | ( property ) |
‣ IsFaithfulQuandle( Q ) | ( property ) |
Returns: true if the right quasigroup Q is a faithful rack/quandle, that is, a rack/quandle with \(x\mapsto R_x\) injective on Q.
The projection right quasigroup is automatically a quandle. We support ProjectionRack and ProjectionQuandle as a synonym of ProjectionRightQuasigroup.
‣ PermutationalRack( n, f[, constructorStyle] ) | ( operation ) |
Returns: the permutational rack on [1..n] via the permutation f, that is, the rack on [1..n] with multiplication x*y = x^f. The permutation f must restrict to [1..n].
Note that for index based right quasigroups it is possible to change the underlying set via ChangeUnderlyingSet, cf. Section 1.4.
gap> PermutationalRack( 10, (3,4,5) ); <rack of size 10> gap> Q := PermutationalRack( 100000, (1,100000), ConstructorStyle( false, true ) ); <rack of size 100000> gap> Q[1]*Q[2]; r100000
‣ CyclicRack( n[, constructorStyle] ) | ( operation ) |
Returns: the cyclic rack on [1..n], that is, the rack on [1..n] with multiplication x*y = x+1, where the addition is with wraparound. This is the same as permutational rack via the n-cycle (1,2,...,n).
A rack is affine if it is an affine right quasigroup over an abelian group (that happens to be a rack). See Section 9.4 for affine right quasigroups and their arithmetic forms. For affine racks, we allow only arithmetic forms (n,f,g,c), (F,f,g,c) and (G,f,g,c).
If \(G\) is an (additive) abelian group, \(f\) an automorphism of \(G\), \(g\) an endomorphism of \(G\) and \(c\in G\), then the affine right quasigroup on \(G\) with arithmetic form \((G,f,g,c)\) and multiplication \(x*y = f(x)+g(y)+c\) is a rack iff \(g(c)=0\), \(fg = gf\) and \(g(f+g-I)\) is the zero mapping, where \(I\) is the identity mapping on \(G\).
In particular, if \(n\) is a positive integer, \(f\) is an integer relatively prime to \(n\), and \(g\), \(c\) are integers, then the affine right quasigroup on \([0..n-1]\) with arithmetic form \((n,f,g,c)\) and multiplication \(x*y = (f*x+g*y+c)\ \mathrm{mod}\ n\) is a rack iff \(gc\equiv 0\pmod n\) and \(g(f+g-1)\equiv 0\pmod n\).
‣ IsAffineRackArithmeticForm( arg ) | ( operation ) |
Returns: true if arg is an arithmetic form of an affine rack. See above for allowed arithmetic forms.
‣ AffineRack( arg[, constructorStyle] ) | ( function ) |
Returns: the affine rack with arithmetic form arg. See above for allowed arithmetic forms.
gap> # affine rack on [0..11] gap> [ IsAffineRackArithmeticForm( 12, 5, 2, 6 ), AffineRack( 12, 5, 2, 6 ) ]; [ true, <rack of size 12> ] gap> # affine rack on GF(9) gap> F := GF(9);; f := 2*Z(9);; g := Z(9)+One(F);; c := Zero(F);; gap> [ IsAffineRackArithmeticForm( F, f, g, c ), AffineRack( F, f, g, c ) ]; # latin racks are quandles [ true, <latin quandle of size 9> ] gap> # affine rack on cyclic group of order 4 gap> x := (1,2,3,4);; G := Group( x );; gap> f := GroupHomomorphismByImages( G, G, [x], [x^-1] );; gap> g := GroupHomomorphismByImages( G, G, [x], [x^2] );; gap> c := x^2;; gap> [ IsAffineRackArithmeticForm( G, f, g, c ), AffineRack( G, f, g, c ) ]; [ true, <rack of size 4> ]
A quandle is affine if it is an affine right quasigroup over an abelian group (that happens to be a quandle). See Section 9.4 for affine right quasigroups and their arithmetic forms.
If \(G\) is an (additive) abelian group, \(f\) an automorphism of \(G\), \(g\) an endomorphism of \(G\) and \(c\in G\), then the affine right quasigroup on \(G\) with arithmetic form \((G,f,g,c)\) and multiplication \(x*y = f(x)+g(y)+c\) is a quandle iff \(c=0\) and \(g=I-f\), where \(I\) is the identity mapping on \(G\). Therefore, for affine quandles, we allow only "shortened" arithmetic forms (n,f), (F,f) and (G,f).
‣ IsAffineQuandleArithmeticForm( arg ) | ( operation ) |
Returns: true if arg is an arithmetic form of an affine quandle. See above for allowed arithmetic forms.
‣ AffineQuandle( arg[, constructorStyle] ) | ( function ) |
Returns: the affine quande with arithmetic form arg. See above for allowed arithmetic forms. The synonym AlexanderQuandle is also supported.
gap> # affine quandle on [0..9] gap> [ IsAffineQuandleArithmeticForm( 10, 3 ), AffineQuandle( 10, 3 ) ]; [ true, <quandle of size 10> ] gap> # affine quandle on GF(9) gap> [ IsAffineQuandleArithmeticForm( GF(9), 2*Z(9) ), AffineQuandle( GF(9), 2*Z(9) ) ]; [ true, <latin quandle of size 9> ] gap> # affine quandle on cyclic group of order 5 gap> G := CyclicGroup(5);; f := Elements( AutomorphismGroup( G ) )[2]; [ f1 ] -> [ f1^2 ] gap> [ IsAffineQuandleArithmeticForm( G, f ), AffineQuandle( G, f ) ]; [ true, <latin quandle of size 5> ]
‣ DihedralQuandle( n[, constructorstyle] ) | ( operation ) |
Returns: the dihedral quandle of size n, that is, the quandle on [0..n-1] with multiplication x*y = (-x+2y) mod n.
‣ CoreOfGroup( G[, constructorStyle] ) | ( operation ) |
Returns: the core of the group (resp. additive group) G defined by \(x*y = (yx^{-1})y\) (resp. \(x*y=y-x+y\)). The core is always a quandle.
Note: The value of constructorStyle.checkArguments of the optional argument constructorStyle does not come into play and need not be specified.
‣ CoreOfRightBolLoop( Q[, constructorStyle] ) | ( operation ) |
Returns: the core of the right Bol loop Q defined by \(x*y = (yx^{-1})y\). The core is always a quandle.
Note: The value of constructorStyle.checkArguments of the optional argument constructorStyle does not come into play and need not be specified.
gap> G := AlternatingGroup( 5 );; gap> Q := CoreOfGroup( G ); <quandle of size 60> gap> Q[(1,2,3)]*Q[(1,2,3,4,5)] = Q[(1,2,3)*(1,2,3,4,5)^(-1)*(1,2,3)]; true gap> CoreOfRightBolLoop( RightBolLoop(8,1) ); <quandle of size 8>
Given a group \(G\), subgroup \(H\) and an automorphism \(f\) of \(G\) that centralizes \(H\), the Galkin quandle (aka coset quandle or homogeneous quandle) is defined on the right cosets \(\{Hx:x\in G\}\) by \(Hx*Hy = H f(xy^{-1})y\).
‣ GalkinQuandle( G, H, f[, constructorStyle] ) | ( operation ) |
Returns: the Galkin quandle constructed from the group G, subgroup H and automorphism f of G that centralizes H. The synonym HomogeneousQuandle is also supported.
gap> G := SymmetricGroup( 4 );; H := Subgroup( G, [(1,2)] );; gap> f := Filtered( AutomorphismGroup( G ), g -> (1,2)^g = (1,2) )[3]; ^(3,4) gap> Q := GalkinQuandle( G, H, f ); <quandle of size 12>
‣ ConjugationQuandle( G[, m[, constructorStyle]] ) | ( function ) |
Returns: the conjugation quandle on G defined by \(x*y = y^{-m}*x*y^m\). The argument G can either be a group or a collection of group elements closed under the above operation. If the optional argument m is omitted, the multiplication is given by \(x*y=y^{-1}*x*y\).
gap> G := SymmetricGroup( 3 );; gap> ConjugationQuandle( G ); # y^-1*x*y on G <quandle of size 6> gap> ConjugationQuandle( ConjugacyClass( G, (1,2,3) ) ); # y^-1*x*y on [ (1,2,3), (1,3,2) ] <quandle of size 2> gap> ConjugationQuandle( G, 2 ); # y^-2*x*y^2 on G <quandle of size 6>
The triple \((G,S,R)\) is a rack envelope if \(G\) is a (permutation) group, \(S\) is a set of orbit representatives of \(G\), and \(R=(r_x:x\in S)\) is a collection of elements of \(G\) such that \(r_x\in C_G(G_x)\) for every \(x\in S\), and \(\langle \bigcup_{x\in S}r_x^G\rangle = G\). Here \(r_x^G\) is the conjugacy class of \(r_x\) in \(G\).
The triple \((G,S,R)\) is a quandle envelope if it is a rack envelope and \(r_x(x)=x\) (that is, \(r_x\in Z(G_x)\)) for every \(x\in S\).
There is a one-to-one correspondence between racks (quandles) and rack envelopes (quandle envelopes) on a given set. This is sometimes called the Joyce-Blackburn representation of racks (quandles). Given a rack/quandle \((Q,\cdot)\), let \(G=\mathrm{Mlt}_r(Q)\) be the right multiplication group of \(Q\), \(S\) a set of orbit representatives of \(G\) on \(Q\), and \(R=(R_x:x\in S)\) (a collection of right transversals). Then \((G,S,R)\) is a rack/quandle envelope. Conversely, given a rack/quandle envelope \((G,S,R)\) on a set \(Q\) with \(R=(r_x:x\in S)\), we can define right translations \(R_y = r_x^{g_y} = g_y^{-1}r_xg_y\), where \(g_y\) is any element of \(G\) such that \(g_y(x)=y\). Then \((Q,\cdot)\) with multiplication \(x\cdot y = R_y(x)\) is a rack/quandle.
In RightQuasigroups, a rack/quandle envelope is represented as a list [G,S,R], where G is a permutation group, S is a list of points (orbit representatives) and R is a list of elements of G, one for each x in S. Functions that use rack/quandle envelopes accept either a single argument [G,S,R] or three arguments G, S, R.
‣ IsRackEnvelope( G, reps, perms ) | ( operation ) |
‣ IsQuandleEnvelope( G, reps, perms ) | ( operation ) |
Returns: true if G, reps, perms is a rack envelope (resp. quandle envelope). For the method to apply, G must be a group and reps, perms must be lists. To return true, G must be a permutation group with orbit representatives reps and perms[i] must be an element of \(C_G(G_x)\) (resp. \(Z(G_x)\)), where x=reps[i], and the union of the conjugacy classes of the permutations in perms must generate G. A version with a single argument [G,reps,perms] is also supported.
‣ RackEnvelope( Q ) | ( operation ) |
‣ QuandleEnvelope( Q ) | ( operation ) |
Returns: the rack envelope (quandle envelope) of the rack (quandle) as a list [G,reps,perms].
‣ RackByRackEnvelope( G, reps, perms[, constructorStyle] ) | ( operation ) |
‣ QuandleByQuandleEnvelope( G, reps, perms[, constructorStyle] ) | ( operation ) |
Returns: the rack (quandle) corresponding to the rack envelope (quandle envelope) [G,reps,perms]. The underlying set will be the union of the orbits of G on the representatives reps. The resulting rack (quandle) is connected if G has a single orbit. A version with a single non-optional argument [G,reps,perms] is also supported.
gap> Q := SmallQuandle( 10, 1000 ); SmallQuandle( 10, 1000 ) gap> env := QuandleEnvelope( Q ); [ Group([ (1,3,2)(7,8) ]), [ 1, 4, 5, 6, 7, 9, 10 ], [ (), (), (1,2,3), (1,3,2)(7,8), (1,2,3), (1,3,2)(7,8), (1,3,2)(7,8) ] ] gap> Q2 := QuandleByQuandleEnvelope( env ); <quandle of size 10> gap> IsomorphismQuandles( Q, Q2 ); MappingByFunction( SmallQuandle( 10, 1000 ), <quandle of size 10>, fun\ ction( x ) ... end ) gap> AsParentTransformation( last ); IdentityTransformation gap> QuandleByQuandleEnvelope( env[1], env[2], env[3] ); # separate arguments also supported for envelopes <quandle of size 10>
‣ IsSubrack( Q, S ) | ( operation ) |
‣ IsSubquandle( Q, S ) | ( operation ) |
Returns: true if S is a subrack (subquandle) of the rack (quandle) Q, else returns false.
‣ Subrack( Q, gens ) | ( operation ) |
‣ Subquandle( Q, gens ) | ( operation ) |
Returns: the subrack (subquandle) of a rack (quandle) Q generated by the list of elements gens. We allow gens to consist of elements of Q or of elements of the underlying set of Q. The resulting subalgebra will be index based (cf. Section 1.8) iff Q is index based.
gap> Q := AffineRack( 12, 5, 2, 6 );; gap> S := Subrack( Q, [ Q[2] ] ); <rack of size 2> gap> IsSubrack( Q, S ); true
‣ AllSubracks( Q ) | ( operation ) |
‣ AllSubquandles( Q ) | ( operation ) |
Returns: a list of all subracks (subquandles) of a rack (quandle) Q.
gap> Q := ConjugationQuandle( SymmetricGroup( 3 ) );; gap> List( AllSubquandles( Q ), Size ); [ 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 5, 2, 4, 6, 3 ]
‣ Rack( gens... ) | ( function ) |
‣ Quandle( gens... ) | ( function ) |
‣ RackByGenerators( gens... ) | ( function ) |
‣ QuandleByGenerators( gens... ) | ( function ) |
‣ RackWithGenerators( gens... ) | ( function ) |
‣ QuandleWithGenerators( gens... ) | ( function ) |
These functions are analogous to those described in Section 3.5
gap> Q := ConjugationQuandle( SymmetricGroup( 3 ) );; gap> S := QuandleWithGenerators( [ Q[(1,2)], Q[(1,2,3)] ] ); <quandle of size 5> gap> GeneratorsOfMagma( S ); [ r(1,2), r(1,2,3) ]
‣ IsomorphismRacks( Q1, Q2 ) | ( operation ) |
‣ IsomorphismQuandles( Q1, Q2 ) | ( operation ) |
Returns: an isomorphism between the racks (quandles) Q1 and Q2, if one exists, else returns fail. If an isomorphism from Q1 to Q2 exists, it is returned as a permutation of \([1..n]\), where \(n\) is the size of Q1 (and hence also the size of Q2).
‣ RacksUpToIsomorphism( ls ) | ( operation ) |
‣ QuandlesUpToIsomorphism( ls ) | ( operation ) |
Returns: a sublist of ls consisting of all racks (quandles) in ls up to isomorphism.
‣ AdjointGroup( Q ) | ( attribute ) |
Returns: the adjoint group associated with the rack Q, that is, the free group on Q with relations \(b^{-1}ab = a*b\), where \(a*b\) is the product in the rack Q. The generators inherit names from the elements of Q.
gap> g := AdjointGroup( DihedralQuandle( 3 ) ); <fp group on the generators [ q0, q1 ]> gap> GeneratorsOfGroup( g ); [ q0, q1 ] gap> RelatorsOfFpGroup( g ); [ q0^-1*q1^2*q0^-1, (q1^-1*q0)^3 ] gap> Size( g ); infinity
generated by GAPDoc2HTML