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