7 Testing Properties of Quasigroups and Loops

7.4 Loops of Bol Moufang Type

7.4-1 IsExtraLoop

7.4-2 IsMoufangLoop

7.4-3 IsCLoop

7.4-4 IsLeftBolLoop

7.4-5 IsRightBolLoop

7.4-6 IsLCLoop

7.4-7 IsRCLoop

7.4-8 IsLeftNuclearSquareLoop

7.4-9 IsMiddleNuclearSquareLoop

7.4-10 IsRightNuclearSquareLoop

7.4-11 IsNuclearSquareLoop

7.4-12 IsFlexible

7.4-13 IsLeftAlternative

7.4-14 IsRightAlternative

7.4-15 IsAlternative

7.4-1 IsExtraLoop

7.4-2 IsMoufangLoop

7.4-3 IsCLoop

7.4-4 IsLeftBolLoop

7.4-5 IsRightBolLoop

7.4-6 IsLCLoop

7.4-7 IsRCLoop

7.4-8 IsLeftNuclearSquareLoop

7.4-9 IsMiddleNuclearSquareLoop

7.4-10 IsRightNuclearSquareLoop

7.4-11 IsNuclearSquareLoop

7.4-12 IsFlexible

7.4-13 IsLeftAlternative

7.4-14 IsRightAlternative

7.4-15 IsAlternative

Although loops are quasigroups, it is often the case in the literature that a property of the same name can differ for quasigroups and loops. For instance, a Steiner loop is not necessarily a Steiner quasigroup.

To avoid such ambivalences, we often include the noun `Loop`

or `Quasigroup`

as part of the name of the property, e.g., `IsSteinerQuasigroup`

versus `IsSteinerLoop`

.

On the other hand, some properties coincide for quasigroups and loops and we therefore do not include `Loop`

, `Quasigroup`

as part of the name of the property, e.g., `IsCommutative`

.

`‣ IsAssociative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an associative quasigroup.

`‣ IsCommutative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a commutative quasigroup.

`‣ IsPowerAssociative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a power associative quasigroup.

A quasigroup \(Q\) is said to be *power associative* if every element of \(Q\) generates an associative quasigroup, that is, a group.

`‣ IsDiassociative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a diassociative quasigroup.

A quasigroup \(Q\) is said to be *diassociative* if any two elements of \(Q\) generate an associative quasigroup, that is, a group. Note that a diassociative quasigroup is necessarily a loop, but it need not be so declared in **LOOPS**.

For an element \(x\) of a loop \(Q\), the *left inverse* of \(x\) is the element \(x^\lambda\) of \(Q\) such that \(x^\lambda \cdot x = 1\), while the *right inverse* of \(x\) is the element \(x^\rho\) of \(Q\) such that \(x\cdot x^\rho = 1\).

`‣ HasLeftInverseProperty` ( Q ) | ( property ) |

`‣ HasRightInverseProperty` ( Q ) | ( property ) |

`‣ HasInverseProperty` ( Q ) | ( property ) |

Returns: `true`

if a loop `Q` has the left inverse property, right inverse property, resp. inverse property.

A loop \(Q\) has the *left inverse property* if \(x^\lambda(xy)=y\) for every \(x\), \(y\) in \(Q\). Dually, \(Q\) has the *right inverse property* if \((yx)x^\rho=y\) for every \(x\), \(y\) in \(Q\). If \(Q\) has both the left inverse property and the right inverse property, it has the *inverse property*.

`‣ HasTwosidedInverses` ( Q ) | ( property ) |

Returns: `true`

if a loop `Q` has two-sided inverses.

A loop \(Q\) is said to have *two-sided inverses* if \(x^\lambda=x^\rho\) for every \(x\) in \(Q\).

`‣ HasWeakInverseProperty` ( Q ) | ( property ) |

Returns: `true`

if a loop `Q` has the weak inverse property.

A loop \(Q\) has the *weak inverse property* if \((xy)^\lambda x = y^\lambda\) (equivalently, \(x(yx)^\rho = y^\rho\)) holds for every \(x\), \(y\) in \(Q\).

`‣ HasAutomorphicInverseProperty` ( Q ) | ( property ) |

Returns: `true`

if a loop `Q` has the automorphic inverse property.

According to [Art59], a loop \(Q\) has the *automorphic inverse property* if \((xy)^\lambda = x^\lambda y^\lambda\), or, equivalently, \((xy)^\rho = x^\rho y^\rho\) holds for every \(x\), \(y\) in \(Q\).

`‣ HasAntiautomorphicInverseProperty` ( Q ) | ( property ) |

Returns: `true`

if a loop `Q` has the antiautomorphic inverse property.

A loop \(Q\) has the *antiautomorphic inverse property* if \((xy)^\lambda=y^\lambda x^\lambda\), or, equivalently, \((xy)^\rho = y^\rho x^\rho\) holds for every \(x\), \(y\) in \(Q\).

See Appendix B for implications implemented in **LOOPS** among various inverse properties.

`‣ IsSemisymmetric` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a semisymmetric quasigroup.

A quasigroup \(Q\) is *semisymmetric* if \((xy)x=y\), or, equivalently \(x(yx)=y\) holds for every \(x\), \(y\) in \(Q\).

`‣ IsTotallySymmetric` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a totally symmetric quasigroup.

A commutative semisymmetric quasigroup is called *totally symmetric*. Totally symmetric quasigroups are precisely the quasigroups satisfying \(xy=x\backslash y = x/y\).

`‣ IsIdempotent` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an idempotent quasigroup.

A quasigroup is *idempotent* if it satisfies \(x^2=x\).

`‣ IsSteinerQuasigroup` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a Steiner quasigroup.

A totally symmetric idempotent quasigroup is called a *Steiner quasigroup*.

A quasigroup \(Q\) is *unipotent* if it satisfies \(x^2=y^2\) for every \(x\), \(y\) in \(Q\).

`‣ IsUnipotent` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a unipotent quasigroup.

`‣ IsLeftDistributive` ( Q ) | ( property ) |

`‣ IsRightDistributive` ( Q ) | ( property ) |

`‣ IsDistributive` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left distributive quasigroup, resp. a right distributive quasigroup, resp. a distributive quasigroup.

A quasigroup is *left distributive* if it satisfies \(x(yz) = (xy)(xz)\), *right distributive* if it satisfies \((xy)z = (xz)(yz)\), and *distributive* if it is both left distributive and right distributive.

**Remark:** In order to be compatible with **GAP**s terminology, we also support the synonyms `IsLDistributive`

and `IsRDistributive`

of `IsLeftDistributive`

and `IsRightDistributive`

, respectively.

`‣ IsEntropic` ( Q ) | ( property ) |

`‣ IsMedial` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an entropic (aka medial) quasigroup.

A quasigroup is *entropic* or *medial* if it satisfies the identity \((xy)(uv) = (xu)(yv)\).

Following [Fen69] and [PV05], a variety of loops is said to be of *Bol-Moufang type* if it is defined by a single *identity of Bol-Moufang type*, i.e., by an identity that contains the same 3 variables on both sides, exactly one of the variables occurs twice on both sides, and the variables occur in the same order on both sides.

It is proved in [PV05] that there are 13 varieties of nonassociative loops of Bol-Moufang type. These are:

*left alternative loops*defined by \(x(xy) = (xx)y\),*right alternative loops*defined by \(x(yy) = (xy)y\),*left nuclear square loops*defined by \((xx)(yz) = ((xx)y)z\),*middle nuclear square loops*defined by \(x((yy)z) = (x(yy))z\),*right nuclear square loops*defined by \(x(y(zz)) = (xy)(zz)\),*flexible loops*defined by \(x(yx) = (xy)x\),*left Bol loops*defined by \(x(y(xz)) = (x(yx))z\), always left alternative,*right Bol loops*defined by \(x((yz)y) = ((xy)z)y\), always right alternative,*LC loops*defined by \((xx)(yz) = (x(xy))z\), always left alternative, left nuclear square and middle nuclear square,*RC loops*defined by \(x((yz)z) = (xy)(zz)\), always right alternative, right nuclear square and middle nuclear square,*Moufang loops*defined by \((xy)(zx) = (x(yz))x\), always flexible, left Bol and right Bol,*C loops*defined by \(x(y(yz)) = ((xy)y)z\), always LC and RC,*extra loops*defined by \(x(y(zx)) = ((xy)z)x\), always Moufang and C.

Note that although some of the defining identities are not of Bol-Moufang type, they are equivalent to a Bol-Moufang identity. Moreover, many varieties of loops of Bol-Moufang type can be defined by one of several equivalent identities of Bol-Moufang type.

There are also several varieties related to loops of Bol-Moufang type. A loop is said to be *alternative* if it is both left alternative and right alternative. A loop is *nuclear square* if it is left nuclear square, middle nuclear square and right nuclear square.

`‣ IsExtraLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an extra loop.

`‣ IsMoufangLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a Moufang loop.

`‣ IsCLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a C loop.

`‣ IsLeftBolLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left Bol loop.

`‣ IsRightBolLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a right Bol loop.

`‣ IsLCLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an LC loop.

`‣ IsRCLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an RC loop.

`‣ IsLeftNuclearSquareLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left nuclear square loop.

`‣ IsMiddleNuclearSquareLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a middle nuclear square loop.

`‣ IsRightNuclearSquareLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a right nuclear square loop.

`‣ IsNuclearSquareLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a nuclear square loop.

`‣ IsFlexible` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a flexible quasigroup.

`‣ IsLeftAlternative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left alternative quasigroup.

`‣ IsRightAlternative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a right alternative quasigroup.

`‣ IsAlternative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an alternative quasigroup.

While listing the varieties of loops of Bol-Moufang type, we have also listed all inclusions among them. These inclusions are built into **LOOPS** as filters.

The following trivial example shows some of the implications and the naming conventions of **LOOPS** at work:

gap> L := LoopByCayleyTable( [ [ 1, 2 ], [ 2, 1 ] ] ); <loop of order 2> gap> [ IsLeftBolLoop( L ), L ] [ true, <left Bol loop of order 2> ] gap> [ HasIsLeftAlternativeLoop( L ), IsLeftAlternativeLoop( L ) ]; [ true, true ] gap> [ HasIsRightBolLoop( L ), IsRightBolLoop( L ) ]; [ false, true ] gap> L; <Moufang loop of order 2> gap> [ IsAssociative( L ), L ]; [ true, <associative loop of order 2> ]

The analogous terminology for quasigroups of Bol-Moufang type is not standard yet, and hence is not supported in **LOOPS** except for the situations explicitly noted above.

A loop is *left power alternative* if it is power associative and satisfies \(x^n(x^m y) = x^{n+m}y\) for all elements \(x\), \(y\) and all integers \(m\), \(n\). Similarly, a loop is *right power alternative* if it is power associative and satisfies \((x y^n)y^m = xy^{n+m}\) for all elements \(x\), \(y\) and all integers \(m\), \(n\). A loop is *power alternative* if it is both left power alternative and right power alternative.

Left power alternative loops are left alternative and have the left inverse property. Left Bol loops and LC loops are left power alternative.

`‣ IsLeftPowerAlternative` ( Q ) | ( property ) |

`‣ IsRightPowerAlternative` ( Q ) | ( property ) |

`‣ IsPowerAlternative` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left power alternative loop, resp. a right power alternative loop, resp. a power alternative loop.

A loop \(Q\) is *left conjugacy closed* if the set of left translations of \(Q\) is closed under conjugation (by itself). Similarly, a loop \(Q\) is *right conjugacy closed* if the set of right translations of \(Q\) is closed under conjugation. A loop is *conjugacy closed* if it is both left conjugacy closed and right conjugacy closed. It is common to refer to these loops as LCC, RCC, and CC loops, respectively.

The equivalence LCC \(+\) RCC \(=\) CC is built into **LOOPS**.

`‣ IsLCCLoop` ( Q ) | ( property ) |

`‣ IsLeftConjugacyClosedLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left conjugacy closed loop.

`‣ IsRCCLoop` ( Q ) | ( property ) |

`‣ IsRightConjugacyClosedLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a right conjugacy closed loop.

`‣ IsCCLoop` ( Q ) | ( property ) |

`‣ IsConjugacyClosedLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a conjugacy closed loop.

`‣ IsOsbornLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an Osborn loop.

A loop is *Osborn* if it satisfies \(x(yz\cdot x)=(x^\lambda\backslash y)(zx)\). Both Moufang loops and CC loops are Osborn.

A loop \(Q\) whose all left (resp. middle, resp. right) inner mappings are automorphisms of \(Q\) is known as a *left automorphic loop* (resp. *middle automorphic loop*, resp. *right automorphic loop*).

A loop \(Q\) is an *automorphic loop* if all inner mappings of \(Q\) are automorphisms of \(Q\).

Automorphic loops are also known as *A loops*, and similar terminology exists for left, right and middle automorphic loops.

The following results hold for automorphic loops:

automorphic loops are power associative [BP56]

in an automorphic loop \(Q\) we have \({\rm Nuc}(Q) = {\rm Nuc}_{\lambda}(Q) = {\rm Nuc}_{\rho}(Q)\le {\rm Nuc}_{\mu}(Q)\) and all nuclei are normal [BP56]

a loop that is left automorphic and right automorphic satisfies the anti-automorphic inverse property and is automorphic [JKNV11]

diassociative automorphic loops are Moufang [KKP02]

automorphic loops of odd order are solvable [KKPV16]

finite commutative automorphic loops are solvable [GKN14]

commutative automorphic loops of order \(p\), \(2p\), \(4p\), \(p^2\), \(2p^2\), \(4p^2\) (\(p\) an odd prime) are abelian groups [Voj15]

commutative automorphic loops of odd prime power order are centrally nilpotent [JKV12]

for any prime \(p\), there are \(7\) commutative automorphic loops of order \(p^3\) up to isomorphism [BGV12]

See the built-in filters and the survey [Voj15] for additional properties of automorphic loops.

`‣ IsLeftAutomorphicLoop` ( Q ) | ( property ) |

`‣ IsLeftALoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left automorphic loop.

`‣ IsMiddleAutomorphicLoop` ( Q ) | ( property ) |

`‣ IsMiddleALoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a middle automorphic loop.

`‣ IsRightAutomorphicLoop` ( Q ) | ( property ) |

`‣ IsRightALoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a right automorphic loop.

`‣ IsAutomorphicLoop` ( Q ) | ( property ) |

`‣ IsALoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is an automorphic loop.

**Remark:** Be careful not to confuse `IsALoop`

and `IsLoop`

.

`‣ IsCodeLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a code loop.

A *code loop* is a Moufang 2-loop with a Frattini subloop of order 1 or 2. Code loops are extra and conjugacy closed.

`‣ IsSteinerLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a Steiner loop.

A *Steiner loop* is an inverse property loop of exponent 2. Steiner loops are commutative.

`‣ IsLeftBruckLoop` ( Q ) | ( property ) |

`‣ IsLeftKLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a left Bruck loop (aka left K loop).

A left Bol loop with the automorphic inverse property is known as a *left Bruck loop* or a *left K loop*.

`‣ IsRightBruckLoop` ( Q ) | ( property ) |

`‣ IsRightKLoop` ( Q ) | ( property ) |

Returns: `true`

if `Q` is a right Bruck loop (aka right K loop).

A right Bol loop with the automorphic inverse property is known as a *right Bruck loop* or a *right K loop*.

generated by GAPDoc2HTML