In this chapter we describe the basic core methods and attributes of the **LOOPS** package.

We associate many attributes with quasigroups in order to speed up computation. This section lists some basic attributes of quasigroups and loops.

`‣ Elements` ( Q ) | ( attribute ) |

Returns: The list of elements of a quasigroup `Q`.

See Section 3.4 for more information about element labels.

`‣ CayleyTable` ( Q ) | ( attribute ) |

Returns: The Cayley table of a quasigroup `Q`.

See Section 4.1 for more information about quasigroup Cayley tables.

`‣ One` ( Q ) | ( attribute ) |

Returns: The identity element of a loop `Q`.

**Remark:**If you want to know if a quasigroup `Q` has a neutral element, you can find out with the standard function for magmas `MultiplicativeNeutralElement(`

.`Q`)

`‣ Size` ( Q ) | ( attribute ) |

Returns: The size of a quasigroup `Q`.

`‣ Exponent` ( Q ) | ( attribute ) |

Returns: The exponent of a power associative loop `Q`. (The method does not test if `Q` is power associative.)

When `Q` is a *power associative loop*, that is, the powers of elements are well-defined in `Q`, then the *exponent* of `Q` is the smallest positive integer divisible by the orders of all elements of `Q`.

Each quasigroup element in **GAP** knows to which quasigroup it belongs. It is therefore possible to perform arithmetic operations with quasigroup elements without referring to the quasigroup. All elements involved in the calculation must belong to the same quasigroup.

Two elements \(x\), \(y\) of the same quasigroup are multiplied by \(x*y\) in **GAP**. Since multiplication of at least three elements is ambiguous in the nonassociative case, we parenthesize elements by default from left to right, i.e., \(x*y*z\) means \(((x*y)*z)\). Of course, one can specify the order of multiplications by providing parentheses.

`‣ LeftDivision` ( x, y ) | ( operation ) |

`‣ RightDivision` ( x, y ) | ( operation ) |

Returns: The left division `x`\(\backslash\)`y` (resp. the right division `x`\(/\)`y`) of two elements `x`, `y` of the same quasigroup.

`‣ LeftDivision` ( S, x ) | ( operation ) |

`‣ LeftDivision` ( x, S ) | ( operation ) |

`‣ RightDivision` ( S, x ) | ( operation ) |

`‣ RightDivision` ( x, S ) | ( operation ) |

Returns: The list of elements obtained by performing the specified arithmetical operation elementwise using a list `S` of elements and an element `x`.

**Remark:** We support \(/\) in place of `RightDivision`

. But we do not support \(\backslash\) in place of `LeftDivision`

.

`‣ LeftDivisionCayleyTable` ( Q ) | ( operation ) |

`‣ RightDivisionCayleyTable` ( Q ) | ( operation ) |

Returns: The Cayley table of the respective arithmetic operation of a quasigroup `Q`.

Powers of elements are generally not well-defined in quasigroups. For magmas and a positive integral exponent, **GAP** calculates powers in the following way: \(x^1=x\), \(x^{2k}=(x^k)\cdot(x^k)\) and \(x^{2k+1}=(x^{2k})\cdot x\). One can easily see that this returns \(x^k\) in about \(\log_2(k)\) steps. For **LOOPS**, we have decided to keep this method, but the user should be aware that the method is sound only in power associative quasigroups.

Let \(x\) be an element of a loop \(Q\) with neutral element \(1\). Then the *left inverse* \(x^\lambda\) of \(x\) is the unique element of \(Q\) satisfying \(x^\lambda x=1\). Similarly, the *right inverse* \(x^\rho\) satisfies \(xx^\rho=1\). If \(x^\lambda=x^\rho\), we call \(x^{-1}=x^\lambda=x^\rho\) the *inverse* of \(x\).

`‣ LeftInverse` ( x ) | ( operation ) |

`‣ RightInverse` ( x ) | ( operation ) |

`‣ Inverse` ( x ) | ( operation ) |

Returns: The left inverse, right inverse and inverse, respectively, of the quasigroup element `x`.

gap> CayleyTable( Q ); [ [ 1, 2, 3, 4, 5 ], [ 2, 1, 4, 5, 3 ], [ 3, 4, 5, 1, 2 ], [ 4, 5, 2, 3, 1 ], [ 5, 3, 1, 2, 4 ] ] gap> elms := Elements( Q ); gap> [ l1, l2, l3, l4, l5 ]; gap> [ LeftInverse( elms[3] ), RightInverse( elms[3] ), Inverse( elms[3] ) ]; [ l5, l4, fail ]

See Section 2.5 for definitions of associators and commutators.

`‣ Associator` ( x, y, z ) | ( operation ) |

Returns: The associator of the elements `x`, `y`, `z` of the same quasigroup.

`‣ Commutator` ( x, y ) | ( operation ) |

Returns: The commutator of the elements `x`, `y` of the same quasigroup.

`‣ GeneratorsOfQuasigroup` ( Q ) | ( attribute ) |

`‣ GeneratorsOfLoop` ( Q ) | ( attribute ) |

Returns: A set of generators of a quasigroup (resp. loop) `Q`. (Both methods are synonyms of `GeneratorsOfMagma`

.)

As usual in **GAP**, one can refer to the `i`

th generator of a quasigroup `Q`

by `Q.i`

. Note that while it is often the case that ` Q.i = Elements(Q)[i]`

, it is not necessarily so.

`‣ GeneratorsSmallest` ( Q ) | ( attribute ) |

Returns: A generating set \(\{q_0\), \(\dots\), \(q_m\}\) of `Q` such that \(Q_0=\emptyset\), \(Q_m=\)`Q`, \(Q_i=\langle q_1\), \(\dots\), \(q_i \rangle\), and \(q_{i+1}\) is the least element of `Q`\(\setminus Q_i\).

`‣ SmallGeneratingSet` ( Q ) | ( attribute ) |

Returns: A small generating set \(\{q_0\), \(\dots\), \(q_m\}\) of `Q` obtained as follows: \(q_0\) is the least element for which \(\langle q_0\rangle\) is largest possible, \(q_1\)$ is the least element for which \(\langle q_0,q_1\) is largest possible, and so on.

generated by GAPDoc2HTML