GAP (Loops) - Chapter 6: Methods Based on Permutation Groups

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 A B Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

6 Methods Based on Permutation Groups
6.1 Parent of a Quasigroup
6.1-1 Parent
6.1-2 Position
6.1-3 PosInParent
6.2 Subquasigroups and Subloops
6.2-1 Subquasigroup
6.2-2 Subloop
6.2-3 IsSubquasigroup and IsSubloop
6.2-4 AllSubquasigroups
6.2-5 AllSubloops
6.2-6 RightCosets
6.2-7 RightTransversal
6.3 Translations and Sections
6.3-1 LeftTranslation and RightTranslation
6.3-2 LeftSection and RightSection
6.4 Multiplication Groups
6.4-1 LeftMutliplicationGroup, RightMultiplicationGroup and MultiplicationGroup
6.4-2 RelativeLeftMultiplicationGroup, RelativeRightMultiplicationGroup and RelativeMultiplicationGroup
6.5 Inner Mapping Groups
6.5-1 LeftInnerMapping, RightInnerMapping, MiddleInnerMapping
6.5-2 LeftInnerMappingGroup, RightInnerMappingGroup, MiddleInnerMappingGroup
6.5-3 InnerMappingGroup
6.6 Nuclei, Commutant, Center, and Associator Subloop
6.6-1 LeftNucles, MiddleNucleus, and RightNucleus
6.6-2 Nuc, NucleusOfQuasigroup and NucleusOfLoop
6.6-3 Commutant
6.6-4 Center
6.6-5 AssociatorSubloop
6.7 Normal Subloops and Simple Loops
6.7-1 IsNormal
6.7-2 NormalClosure
6.7-3 IsSimple
6.8 Factor Loops
6.8-1 FactorLoop
6.8-2 NaturalHomomorphismByNormalSubloop
6.9 Nilpotency and Central Series
6.9-1 IsNilpotent
6.9-2 NilpotencyClassOfLoop
6.9-3 IsStronglyNilpotent
6.9-4 UpperCentralSeries
6.9-5 LowerCentralSeries
6.10 Solvability, Derived Series and Frattini Subloop
6.10-1 IsSolvable
6.10-2 DerivedSubloop
6.10-3 DerivedLength
6.10-4 FrattiniSubloop and FrattinifactorSize
6.10-5 FrattinifactorSize
6.11 Isomorphisms and Automorphisms
6.11-1 IsomorphismQuasigroups
6.11-2 IsomorphismLoops
6.11-3 QuasigroupsUpToIsomorphism
6.11-4 LoopsUpToIsomorphism
6.11-5 AutomorphismGroup
6.11-6 QuasigroupIsomorph
6.11-7 LoopIsomorph
6.11-8 IsomorphicCopyByPerm
6.11-9 IsomorphicCopyByNormalSubloop
6.11-10 Discriminator
6.11-11 AreEqualDiscriminators
6.12 Isotopisms
6.12-1 IsotopismLoops
6.12-2 LoopsUpToIsotopism

### 6 Methods Based on Permutation Groups

Most calculations in the LOOPS package are delegated to groups, taking advantage of the various permutations and permutation groups associated with quasigroups. This chapter explains in detail how the permutations associated with a quasigroup are calculated, and it also describes some of the core methods of LOOPS based on permutations. Additional core methods can be found in Chapter 7.

#### 6.1 Parent of a Quasigroup

Let Q be a quasigroup and S a subquasigroup of Q. Since the multiplication in S coincides with the multiplication in Q, it is reasonable not to store the multiplication table of S. However, the quasigroup S then must know that it is a subquasigroup of Q.

##### 6.1-1 Parent

`‣ Parent`( Q ) | ( attribute )

Returns: The parent quasigroup of the quasigroup Q.

When Q is not created as a subquasigroup of another quasigroup, the attribute `Parent(Q)` is set to Q. When Q is created as a subquasigroup of a quasigroup H, we set `Parent(Q)` equal to `Parent(H)`. Thus, in effect, `Parent(Q)` is the largest quasigroup from which Q has been created.

##### 6.1-2 Position

`‣ Position`( Q, x ) | ( operation )

Returns: The position of x among the elements of Q.

Let Q be a quasigroup with parent P, where P is some n-element quasigroup. Let x be an element of Q. Then `x![1]` is the position of x among the elements of P, i.e., `x![1] = Position(Elements(P),x)`.

While referring to elements of Q by their positions, the user should understand whether the positions are meant among the elements of Q, or among the elements of the parent P of Q. Since it requires no calculation to obtain `x![1]`, we always use the position of an element in its parent quasigroup in LOOPS. In this way, many attributes of a quasigroup, including its Cayley table, are permanently tied to its parent.

It is now clear why we have not insisted that Cayley tables of quasigroups must have entries covering the entire interval 1, dots, n for some n.

##### 6.1-3 PosInParent

`‣ PosInParent`( S ) | ( operation )

Returns: When S is a list of quasigroup elements (not necessarily from the same quasigroup), returns the corresponding list of positions of elements of S in the corresponding parent, i.e., `PosInParent(S)[i] = S[i]![1] = Position(Parent(S[i]),S[i])`.

Quasigroups with the same parent can be compared as follows. Assume that A, B are two quasigroups with common parent Q. Let G_A, G_B be the canonical generating sets of A and B, respectively, obtained by the method `GeneratorsSmallest` (see Section 5.5). Then we define A<B if and only if G_A<G_B lexicographically.

#### 6.2 Subquasigroups and Subloops

##### 6.2-1 Subquasigroup

`‣ Subquasigroup`( Q, S ) | ( operation )

Returns: When S is a subset of elements or indices of a quasigroup (resp. loop) Q, returns the smallest subquasigroup (resp. subloop) of Q containing S.

We allow S to be a list of elements of Q, or a list of integers representing the positions of the respective elements in the parent quasigroup (resp. loop) of Q.

If S is empty, `Subquasigroup(Q,S)` returns the empty set if Q is a quasigroup, and it returns the one-element subloop of Q if Q is a loop.

Remark: The empty set is sometimes considered to be a subquasigroup of Q (although not in LOOPS). The above convention is useful for handling certain situations, for instance when the user calls `Center(Q)` for a quasigroup Q with empty center.

##### 6.2-2 Subloop

`‣ Subloop`( Q, S ) | ( operation )

This is an analog of `Subquasigroup(Q,S)` that can be used only when Q is a loop. Since there is no difference in the outcome while calling `Subquasigroup(Q,S)` or `Subloop(Q,S)` when Q is a loop, it is safe to always call `Subquasigroup(Q,S)`, whether Q is a loop or not.

##### 6.2-3 IsSubquasigroup and IsSubloop

`‣ IsSubquasigroup`( Q, S ) | ( operation )

`‣ IsSubloop`( Q, S ) | ( operation )

Returns: `true` if S is a subquasigroup (resp. subloop) of a quasigroup (resp. loop) Q, `false` otherwise. In other words, returns `true` if S and Q are quasigroups (resp. loops) with the same parent and S is a subset of Q.

##### 6.2-4 AllSubquasigroups

`‣ AllSubquasigroups`( Q ) | ( operation )

Returns: A list of all subquasigroups of a loop Q.

##### 6.2-5 AllSubloops

`‣ AllSubloops`( Q ) | ( operation )

Returns: A list of all subloops of a loop Q.

##### 6.2-6 RightCosets

`‣ RightCosets`( Q, S ) | ( function )

Returns: If S is a subloop of Q, returns a list of all right cosets of S in Q.

The coset S is listed first, and the elements of each coset are ordered in the same way as the elements of S, i.e., if S= [s_1,dots,s_m], then Sx=[s_1x,dots,s_mx].

##### 6.2-7 RightTransversal

`‣ RightTransversal`( Q, S ) | ( operation )

Returns: A right transversal of a subloop S in a loop Q. The transversal consists of the list of first elements from the right cosets obtained by `RightCosets(Q,S)`.

When S is a subloop of Q, the right transversal of S with respect to Q is a subset of Q containing one element from each right coset of S in Q.

#### 6.3 Translations and Sections

When x is an element of a quasigroup Q, the left translation L_x is a permutation of Q. In LOOPS, all permutations associated with quasigroups and their elements are permutations in the sense of GAP, i.e., they are bijections of some interval 1, dots, n. Moreover, following our convention, the numerical entries of the permutations point to the positions among elements of the parent of Q, not among elements of Q.

##### 6.3-1 LeftTranslation and RightTranslation

`‣ LeftTranslation`( Q, x ) | ( operation )

`‣ RightTranslation`( Q, x ) | ( operation )

Returns: If x is an element of a quasigroup Q, returns the left translation (resp. right translation) by x in Q.

##### 6.3-2 LeftSection and RightSection

`‣ LeftSection`( Q ) | ( operation )

`‣ RightSection`( Q ) | ( operation )

Returns: The left section (resp. right section) of a quasigroup Q.

Here is an example illustrating the main features of the subquasigroup construction and the relationship between a quasigroup and its parent.

Note how the Cayley table of a subquasigroup is created only upon explicit demand. Also note that changing the names of elements of a subquasigroup (subloop) automatically changes the names of the elements of the parent subquasigroup (subloop). This is because the elements are shared.

    gap> M := MoufangLoop( 12, 1 );; S := Subloop( M, [ M.5 ] );
    <loop of order 3>
    gap> [ Parent( S ) = M, Elements( S ), PosInParent( S ) ];
    [ true, [ l1, l3, l5], [ 1, 3, 5 ] ]
    gap> HasCayleyTable( S );
    false
    gap> SetLoopElmName( S, "s" );; Elements( S ); Elements( M );
    [ s1, s3, s5 ]
    [ s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12 ]
    gap> CayleyTable( S );
    [ [ 1, 3, 5 ], [ 3, 5, 1 ], [ 5, 1, 3 ] ]
    gap> LeftSection( S );
    [ (), (1,3,5), (1,5,3) ]
    gap> [ HasCayleyTable( S ), Parent( S ) = M ];
    [ true, true ]
    gap> L := LoopByCayleyTable( CayleyTable( S ) );; Elements( L );
    [ l1, l2, l3 ]
    gap> [ Parent( L ) = L, IsSubloop( M, S ), IsSubloop( M, L ) ];
    [ true, true, false ]
    gap> LeftSection( L );
    [ (), (1,2,3), (1,3,2) ]

#### 6.4 Multiplication Groups

##### 6.4-1 LeftMutliplicationGroup, RightMultiplicationGroup and MultiplicationGroup

`‣ LeftMultiplicationGroup`( Q ) | ( attribute )

`‣ RightMultiplicationGroup`( Q ) | ( attribute )

`‣ MultiplicationGroup`( Q ) | ( attribute )

Returns: The left multiplication group, right multiplication group, resp. multiplication group of a quasigroup Q.

##### 6.4-2 RelativeLeftMultiplicationGroup, RelativeRightMultiplicationGroup and RelativeMultiplicationGroup

`‣ RelativeLeftMultiplicationGroup`( Q, S ) | ( operation )

`‣ RelativeRightMultiplicationGroup`( Q, S ) | ( operation )

`‣ RelativeMultiplicationGroup`( Q, S ) | ( operation )

Returns: The relative left multiplication group, the relative right multiplication group, resp. the relative multiplication group of a quasigroup Q with respect to a subquasigroup S of Q.

Let S be a subquasigroup of a quasigroup Q. Then the relative left multiplication group of Q with respect to S is the group ⟨ L(x)|x∈ S⟩, where L(x) is the left translation by x in Q restricted to S. The relative right multiplication group and the relative multiplication group are defined analogously.

#### 6.5 Inner Mapping Groups

By a result of Bruck, the left inner mapping group of a loop is generated by all left inner mappings L(x,y) = L_yx^-1L_yL_x, and the right inner mapping group is generated by all right inner mappings R(x,y) = R_xy^-1R_yR_x.

In analogy with group theory, we define the conjugations or the middle inner mappings as T(x) = L_x^-1R_x. The middle inner mapping grroup is then the group generated by all conjugations.

##### 6.5-1 LeftInnerMapping, RightInnerMapping, MiddleInnerMapping

`‣ LeftInnerMapping`( Q, x, y ) | ( operation )

`‣ RightInnerMapping`( Q, x, y ) | ( operation )

`‣ MiddleInnerMapping`( Q, x ) | ( operation )

Returns: The left inner mapping L(x,y), the right inner mapping R(x,y), resp. the middle inner mapping T(x) of a loop Q.

##### 6.5-2 LeftInnerMappingGroup, RightInnerMappingGroup, MiddleInnerMappingGroup

`‣ LeftInnerMappingGroup`( Q ) | ( attribute )

`‣ RightInnerMappingGroup`( Q ) | ( attribute )

`‣ MiddleInnerMappingGroup`( Q ) | ( attribute )

Returns: The left inner mapping group, right inner mapping group, resp. middle inner mapping group of a loop Q.

##### 6.5-3 InnerMappingGroup

`‣ InnerMappingGroup`( Q ) | ( attribute )

Returns: The inner mapping group of a loop Q.

Here is an example for multiplication groups and inner mapping groups:

    gap> M := MoufangLoop(12,1);
    <Moufang loop 12/1>
    gap> LeftSection(M)[2];
    (1,2)(3,4)(5,6)(7,8)(9,12)(10,11)
    gap> Mlt := MultiplicationGroup(M); Inn := InnerMappingGroup(M);
    <permutation group of size 2592 with 23 generators>
    Group([ (4,6)(7,11), (7,11)(8,10), (2,6,4)(7,9,11), (3,5)(9,11), (8,12,10) ])
    gap> Size(Inn);
    216

#### 6.6 Nuclei, Commutant, Center, and Associator Subloop

See Section 2.3 for the relevant definitions.

##### 6.6-1 LeftNucles, MiddleNucleus, and RightNucleus

`‣ LeftNucleus`( Q ) | ( attribute )

`‣ MiddleNucleus`( Q ) | ( attribute )

`‣ RightNucleus`( Q ) | ( attribute )

Returns: The left nucleus, middle nucleus, resp. right nucleus of a quasigroup Q.

##### 6.6-2 Nuc, NucleusOfQuasigroup and NucleusOfLoop

`‣ Nuc`( Q ) | ( attribute )

`‣ NucleusOfQuasigroup`( Q ) | ( attribute )

`‣ NucleusOfLoop`( Q ) | ( attribute )

Returns: These synonymous attributes return the nucleus of a quasigroup Q.

Since all nuclei are subquasigroups of Q, they are returned as subquasigroups (resp. subloops). When Q is a loop then all nuclei are in fact groups, and they are returned as associative loops.

Remark: The name `Nucleus` is a global function of GAP with two variables. We have therefore used `Nuc` rather than `Nucleus` for the nucleus. This abbreviation is sometimes used in the literature, too.

##### 6.6-3 Commutant

`‣ Commutant`( Q ) | ( attribute )

Returns: The commutant of a quasigroup Q.

##### 6.6-4 Center

`‣ Center`( Q ) | ( attribute )

Returns: The center of a quasigroup Q.

If Q is a loop, the center of Q is a subgroup of Q and it is returned as an associative loop.

##### 6.6-5 AssociatorSubloop

`‣ AssociatorSubloop`( Q ) | ( attribute )

Returns: The associator subloop of a loop Q.

We calculate the associator subloop of Q as the smallest normal subloop of Q containing all elements xbackslashα(x), where x is an element of Q and α is a left inner mapping of Q.

#### 6.7 Normal Subloops and Simple Loops

##### 6.7-1 IsNormal

`‣ IsNormal`( Q, S ) | ( operation )

Returns: `true` if S is a normal subloop of a loop Q.

A subloop S of a loop Q is normal if it is invariant under all inner mappings of Q.

##### 6.7-2 NormalClosure

`‣ NormalClosure`( Q, S ) | ( operation )

Returns: The normal closure of a subset S of a loop Q.

For a subset S of a loop Q, the normal closure of S in Q is the smallest normal subloop of Q containing S.

##### 6.7-3 IsSimple

`‣ IsSimple`( Q ) | ( operation )

Returns: `true` if Q is a simple loop.

A loop Q is simple if {1} and Q are the only normal subloops of Q.

#### 6.8 Factor Loops

##### 6.8-1 FactorLoop

`‣ FactorLoop`( Q, S ) | ( operation )

Returns: When S is a normal subloop of a loop Q, returns the factor loop Q/S.

##### 6.8-2 NaturalHomomorphismByNormalSubloop

`‣ NaturalHomomorphismByNormalSubloop`( Q, S ) | ( operation )

Returns: When S is a normal subloop of a loop Q, returns the natural projection from Q onto Q/S.

    gap> M := MoufangLoop( 12, 1 );; S := Subloop( M, [ M.3 ] );
    <loop of order 3>
    gap> IsNormal( M, S );
    true
    gap> F := FactorLoop( M, S );
    <loop of order 4>
    gap> NaturalHomomorphismByNormalSubloop( M, S );
    MappingByFunction( <loop of order 12>, <loop of order 4>,
        function( x ) ... end )

#### 6.9 Nilpotency and Central Series

See Section 2.4 for the relevant definitions.

##### 6.9-1 IsNilpotent

`‣ IsNilpotent`( Q ) | ( property )

Returns: `true` if Q is a nilpotent loop.

##### 6.9-2 NilpotencyClassOfLoop

`‣ NilpotencyClassOfLoop`( Q ) | ( attribute )

Returns: The nilpotency class of a loop Q if Q is nilpotent, `fail` otherwise.

##### 6.9-3 IsStronglyNilpotent

`‣ IsStronglyNilpotent`( Q ) | ( property )

Returns: `true` if Q is a strongly nilpotent loop.

A loop Q is said to be strongly nilpotent if its multiplication group is nilpotent.

##### 6.9-4 UpperCentralSeries

`‣ UpperCentralSeries`( Q ) | ( attribute )

Returns: When Q is a nilpotent loop, returns the upper central series of Q, else returns `fail`.

##### 6.9-5 LowerCentralSeries

`‣ LowerCentralSeries`( Q ) | ( attribute )

Returns: When Q is a nilpotent loop, returns the lower central series of Q, else returns `fail`.

The lower central series for loops is defined analogously to groups.

#### 6.10 Solvability, Derived Series and Frattini Subloop

See Section 2.4 for definitions of solvability an derived subloop.

##### 6.10-1 IsSolvable

`‣ IsSolvable`( Q ) | ( property )

Returns: `true` if Q is a solvable loop.

##### 6.10-2 DerivedSubloop

`‣ DerivedSubloop`( Q ) | ( attribute )

Returns: The derived subloop of a loop Q.

##### 6.10-3 DerivedLength

`‣ DerivedLength`( Q ) | ( attribute )

Returns: If Q is solvable, returns the derived length of Q, else returns `fail`.

##### 6.10-4 FrattiniSubloop and FrattinifactorSize

`‣ FrattiniSubloop`( Q ) | ( attribute )

Returns: The Frattini subloop of Q. The method is implemented only for strongly nilpotent loops.

Frattini subloop of a loop Q is the intersection of maximal subloops of Q.

##### 6.10-5 FrattinifactorSize

`‣ FrattinifactorSize`( Q ) | ( attribute )

#### 6.11 Isomorphisms and Automorphisms

##### 6.11-1 IsomorphismQuasigroups

`‣ IsomorphismQuasigroups`( Q, L ) | ( operation )

Returns: An isomorphism from a quasigroup Q to a quasigroup L if the quasigroups are isomorphic, `fail` otherwise.

If an isomorphism exists, it is returned as a permutation f of 1,dots,|Q|, where i^f=j means that the ith element of Q is mapped onto the jth element of L. Note that this convention is used even if the underlying sets of Q, L are not indexed by consecutive integers.

##### 6.11-2 IsomorphismLoops

`‣ IsomorphismLoops`( Q, L ) | ( operation )

Returns: An isomorphism from a loop Q to a loop L if the loops are isomorphic, `fail` otherwise, with the same convention as in `IsomorphismQuasigroups`.

##### 6.11-3 QuasigroupsUpToIsomorphism

`‣ QuasigroupsUpToIsomorphism`( ls ) | ( operation )

Returns: Given a list ls of quasigroups, returns a sublist of ls consisting of representatives of isomorphism classes of quasigroups from ls.

##### 6.11-4 LoopsUpToIsomorphism

`‣ LoopsUpToIsomorphism`( ls ) | ( operation )

Returns: Given a list ls of loops, returns a sublist of ls consisting of representatives of isomorphism classes of loops from ls.

##### 6.11-5 AutomorphismGroup

`‣ AutomorphismGroup`( Q ) | ( attribute )

Returns: The automorphism group of a loop or quasigroups Q, with the same convention on permutations as in `IsomorphismQuasigroups`.

Remark: Since two isomorphisms differ by an automorphism, all isomorphisms from Q to L can be obtained by a combination of `IsomorphismLoops(Q,L)` (or `IsomorphismQuasigroups(Q,L)`) and `AutomorphismGroup(L)`.

While dealing with Cayley tables, it is often useful to rename or reorder the elements of the underlying quasigroup without changing the isomorphism type of the quasigroups. LOOPS contains several functions for this purpose.

##### 6.11-6 QuasigroupIsomorph

`‣ QuasigroupIsomorph`( Q, f ) | ( operation )

Returns: When Q is a quasigroup and f is a permutation of 1,dots,|Q|, returns the quasigroup defined on the same set as Q with multiplication * defined by x*y =f(f^-1(x)f^-1(y)).

##### 6.11-7 LoopIsomorph

`‣ LoopIsomorph`( Q, f ) | ( operation )

Returns: When Q is a loop and f is a permutation of 1,dots,|Q| fixing 1, returns the loop defined on the same set as Q with multiplication * defined by x*y =f(f^-1(x)f^-1(y)). If f(1)=cne 1, the isomorphism (1,c) is applied after f.

##### 6.11-8 IsomorphicCopyByPerm

`‣ IsomorphicCopyByPerm`( Q, f ) | ( operation )

Returns: `LoopIsomorphism(Q,f)` if Q is a loop, and `QuasigroupIsomorphism(Q,f)` if Q is a quasigroup.

##### 6.11-9 IsomorphicCopyByNormalSubloop

`‣ IsomorphicCopyByNormalSubloop`( Q, S ) | ( operation )

Returns: When S is a normal subloop of a loop Q, returns an isomorphic copy of Q in which the elements are ordered according to the right cosets of S. In particular, the Cayley table of S will appear in the top left corner of the Cayley table of the resulting loop.

In order to speed up the search for isomorphisms and automorphisms, we first calculate some loop invariants preserved under isomorphisms, and then we use these invariants to partition the loop into blocks of elements preserved under isomorphisms. The following two operations are used in the search.

##### 6.11-10 Discriminator

`‣ Discriminator`( Q ) | ( operation )

Returns: A data structure with isomorphism invariants of a loop Q.

See [Voj06] or the file `iso.gi` for more details. The format of the discriminator has been changed from version 3.2.0 up to accommodate isomorphism searches for quasigroups.

If two loops have different discriminators, they are not isomorphic. If they have identical discriminators, they may or may not be isomorphic.

##### 6.11-11 AreEqualDiscriminators

`‣ AreEqualDiscriminators`( D1, D2 ) | ( operation )

Returns: `true` if D1, D2 are equal discriminators for the purposes of isomorphism searches.

#### 6.12 Isotopisms

At the moment, LOOPS contains only slow methods for testing if two loops are isotopic. The method works as follows: It is well known that if a loop K is isotopic to a loop L then there exist a principal loop isotope P of K such that P is isomorphic to L. The algorithm first finds all principal isotopes of K, then filters them up to isomorphism, and then checks if any of them is isomorphic to L. This is rather slow already for small orders.

##### 6.12-1 IsotopismLoops

`‣ IsotopismLoops`( K, L ) | ( operation )

Returns: `fail` if K, L are not isotopic loops, else it returns an isotopism as a triple of bijections on 1,dots,|K|.

##### 6.12-2 LoopsUpToIsotopism

`‣ LoopsUpToIsotopism`( ls ) | ( operation )

Returns: Given a list ls of loops, returns a sublist of ls consisting of representatives of isotopism classes of loops from ls.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 A B Bib Ind

generated by GAPDoc2HTML