Listing Words in Free Groups

TL;DR

This paper introduces efficient algorithms for generating conjugacy classes and relators in free groups, corresponding to necklaces and bracelets, with evidence suggesting they operate in constant amortized time.

Contribution

The paper presents novel algorithms for generating freely and cyclically reduced necklaces and bracelets in free groups, improving efficiency in combinatorial group theory.

Findings

Algorithms run in constant amortized time

Effective generation of conjugacy classes and relators

Applicable to combinatorial group theory problems

Abstract

Lists of equivalence classes of words under rotation or rotation plus reversal (i.e., necklaces and bracelets) have many uses, and efficient algorithms for generating these lists exist. In combinatorial group theory elements of a group are typically written as words in the generators and their inverses, and necklaces and bracelets correspond to conjugacy classes and relators respectively. We present algorithms to generate lists of freely and cyclically reduced necklaces and bracelets in free groups. Experimental evidence suggests that these algorithms are CAT -- that is, they run in constant amortized time.

Figures

Equations

$$\mathcal{C}(g,\ell )=\{\begin{array}{ll}(2g-1{)}^{\ell }+1,& \text{if ℓ is odd;}\\ (2g-1{)}^{\ell }+2g-1,& \text{if ℓ is even.}\end{array}$$

$$\mathcal{CC}(g,\ell )=\frac{1}{\ell }\sum _{d\mid \ell }\varphi (d)\mathcal{C}(g,\ell /d).$$

$$\tau (g,\ell )=\sum _{d\mid \ell }\mu \left(\frac{\ell }{d}\right)\mathcal{C}(g,d).$$

Full text

{AMS}

05A05, 20E05, 20E45, 20F05

1 Introduction

Given an ordered alphabet of size $k$, a necklace of length $n$ is the lexicographically least element of an equivalence class of $k$-ary strings of length $n$ under rotation. A word is called a prenecklace if it is the prefix of some necklace. An aperiodic necklace is called a Lyndon word. A bracelet of length $n$ is the lexicographically least element of an equivalence class of $k$-ary strings of length $n$ under string rotation and string reversal.

For a fixed $k$ the number of necklaces (also Lydon words, prenecklaces and bracelets) grows exponentially with the length. See, for example, [3, 13] for exact counts and bounds. So generating a complete list of the length $n$ necklaces takes exponential time, and our goal is an algorithm where the computation (the total amount of change to the data structures, not including any processing of the generated necklaces) is proportional to the number of necklaces generated. Such an algorithm is a constant amortized time, or CAT, algorithm.

In group theory, elements of a group can be represented by strings (or words) in the group’s generators and their inverses. Symbolic algebra systems such as GAP and Magma [1, 2] make sophisticated testing of large numbers of examples straightforward, and efficient algorithms for generating complete lists of words, up to some equivalence, are an important part of this. The extant enumeration algorithms do not take into account the group structure, and we demonstrate how they can be recast to address this. For necklaces this process is trivial, while for bracelets we need modify the reversal checking code materially.

The remainder of this paper is organized as follows. Section 2 gives some background material on necklaces and bracelets and on free groups and group presentations, and discusses the analogues of necklaces and bracelets in groups. Sections 3 and 4, respectively, describe our necklace and bracelet listing algorithms, and we discuss our results in Section 5. Appendix A describes the tests we performed on the running times of our algorithms.

2 Background

The first algorithm for generating necklaces, the FKM algorithm (due to Fredericksen, Kessler and Maiorana [6, 7]), was proved to be CAT in [11]. A simple recursive CAT algorithm to generate prenecklaces, necklaces and Lyndon words was given in [3], and it is this algorithm which forms the basis of our work.

Duval’s algorithm for factoring a string, of length $n$, into Lyndon words [5] yields an algorithm for generating the necklace of the string in $O(n)$ time. Thus a straightforward approach to generating bracelets is to generate the necklaces and to reject those where the necklace of the reversal is less than the necklace. However, this does not yield a CAT algorithm. The algorithm given in [13] is based on the recursive algorithm of [3] and maintains auxiliary data regarding the current prenecklace, using this to guide testing against its reversal and control the computation. The total amount of extra work, amortized over all bracelets, is constant, so this bracelet generating algorithm is CAT.

Given a set $S$ of $g$ symbols define the set $S^{\prime}=S\cup\{s^{-1}:s\in S\}$. The set of all words on $S^{\prime}$ is $F_{g}$, the free group of rank $g$. The group operation is concatenation, $s^{-1}$ is read as the inverse of $s$, and the empty word is the identity element. Words with no substrings of the form $ss^{-1}$ or $s^{-1}s$ are called freely reduced. Two words represent the same element of $F_{g}$ if and only if they are identical after being freely reduced. (See [8, 9] for more details on combinatorial group theory.)

Let $w=s_{1}\cdots s_{\ell}\in F_{g}$. If $s_{1}$ and $s_{\ell}$ are not inverses of each other, then $w$ is cyclically reduced. Given an $r\in S^{\prime}$ then the word $r^{-1}wr$ is the conjugate of $w$ by $r$, denoted $w^{r}$. If $r=s_{1}$ (resp., $s_{\ell}^{-1}$) and the substring $r^{-1}s_{1}$ (resp., $s_{\ell}r$) is canceled from $w^{r}$ then the resulting word is a rotation of $w$ by one position. If $r=s_{1}=s_{\ell}^{-1}$ then canceling $r^{-1}s_{1}$ and $s_{\ell}r$ performs a cyclic reduction step and reduces the length of $w$ by two. Repeated conjugation of a word may render it cyclically reduced or freely reduced, rotate it arbitrarily, or increase its length arbitrarily.

Conjugation partitions the words in $F_{g}$ into conjugacy classes. Given an order on $S^{\prime}$, we take as class representatives the lexicographically least element of the freely and cyclically reduced words in the class. So, in the context of $F_{g}$, listing the freely and cyclically reduced necklaces of length $\ell$ is equivalent to listing the conjugacy classes whose shortest words have length $\ell$. A word which is both freely reduced and cyclically reduced will be called simply reduced.

Reversing a word $w$ is not meaningful in $F_{g}$. However reversing $w$ and then replacing each of its elements by its inverse generates $w^{-1}$ (i.e., freely reducing $ww^{-1}$ or $w^{-1}w$ results in the empty word). Given a set of words $R$ in $F_{g}$, the normal closure $N$ of $R$ in $F_{g}$ is the set of all words which are concatenations of conjugates of the words in $R$ and their inverses. Groups are often described as quotient groups of free groups and $N$ is a normal subgroup of $F_{g}$, so the quotient $F_{g}/N$ describes some group $G$. (Formally, there is a homomorphism from $F_{g}$ onto $G$ with kernal $N$, see [8, 9].)

The pair $(S,R)$ is a presentation for $G$, written as $G=\langle S:R\rangle$. The elements of $S$ are the generators of $G$. The words in $R$ are equal to the identity in $G$ and are called relators. So, in the context of $F_{g}$, listing the reduced bracelets of length $\ell$ is equivalent to listing equivalence classes of possible relators of length $\ell$ in a presentation.

Enumerating reduced necklaces and bracelets in groups is equivalent to enumerating general necklaces and bracelets with forbidden substrings. An efficient algorithm exists to enumerate necklaces with a forbidden substring [12], however the analysis therein assumes that the substring has length at least three. For substrings of length one or two, [12] notes that “trivial algorithms can be developed”. In our case, we simply test each potential addition to the current prenecklace, and skip those which cannot yield a reduced necklace.

In the remainder of this paper, unless explicitly stated otherwise, we are always working in the free group $F_{g}$. The number of group generators will be denoted by $g$ and the word length by $\ell$ (both assumed positive), with the set of possible symbols in our words having size $k=2g$. From [10, Theorems 1.1 & 14.2] we have the following result.

Theorem 2.1**.**

The number of reduced words of length $\ell$ in $F_{g}$ is equal to

[TABLE]

Let $\phi$ denote the Euler totient function. Then the number of reduced necklaces of length $\ell$ in $F_{g}$ is equal to

[TABLE]

In the general case (i.e, not in $F_{g}$) it is possible for a necklace and its reversal to be equal, up to rotation – consider the necklace $ababb$ and its reversal $bbaba$. However, in $F_{g}$ a reduced necklace cannot be equal to its inverse or any of its inverse’s rotations. More generally, we have the following result.

Lemma 2.2**.**

*Let $w$ be a freely reduced word of length $\ell>0$ in $F_{g}$. Then no conjugate of $w^{-1}$ equals $w$. *

Proof 2.3**.**

Let $w=s_{1}\cdots s_{\ell}$, and write $1$ for the empty word and $\bar{x}$ for $x^{-1}$.

(i) We first prove that $w\neq\bar{w}$. If $w=\bar{w}$ then $w$ is its own inverse and so $ww=1$. Now put $w=\bar{u}vu$, where $u,v\in F_{g}$ are freely reduced and $u$ has maximal length. Since $w$ is freely reduced, $v$ is non-empty and, by $u$’s maximality, there is no free reduction in $vv$. Thus $ww=\bar{u}vu\bar{u}vu=\bar{u}vvu$ is a freely reduced non-empty word, contradicting $ww=1$.

(ii) Now assume that $w_{r}=\bar{s}_{k}\cdots\bar{s}_{1}\bar{s}_{\ell}\cdots\bar{s}_{k+1}$, $1\leqslant k\leqslant\ell-1$, is a proper rotation of $\bar{w}$ which equals $w$. If $\bar{s}_{1}\bar{s}_{\ell}=1$ then free reduction of $w_{r}$ yields a word of length $n<\ell$, so $w\neq w_{r}$. Thus $w_{r}$ must be freely reduced, and $w=w_{r}$ implies that $w_{1}=\bar{s}_{k}\cdots\bar{s}_{1}=s_{1}\cdots s_{k}=\bar{w}_{1}$. However this is impossible (part (i), with $w=w_{1}$), so $\bar{w}$ is not a proper rotation of $w$.

*(iii) Now consider arbitrary conjugation of $\bar{w}$, followed by free reduction. If this yields a word of length $n\neq\ell$, then $w\neq\bar{w}$. If not, then part (i) or (ii) applies. *

Thus the set of reduced necklaces in $F_{g}$ of length $\ell$ can be partitioned into pairs, where the words in a pair are inverses (up to rotation) and are not equal under rotation. So precisely one member of each pair is a bracelet, and the number of reduced bracelets of length $\ell$ in $F_{g}$ is $\mathcal{CC}(g,\ell)/2$.

In some applications we may only be interested in aperiodic (or prime) words, and it is trivial to modify our algorithms to generate these (see Section 5). From [4, Equation (2.2)] we have the following result.

Theorem 2.4**.**

Let $\mu$ denote the Möbius function. Then the number of reduced prime words of length $\ell$ in $F_{g}$ is equal to

[TABLE]

Thus, in $F_{g}$ there are $\tau(g,\ell)/\ell$ reduced necklaces and $\tau(g,\ell)/2\ell$ reduced bracelets of length $\ell$ which are not proper powers.

For $F_{1}$, with generator $z$, there are only two reduced necklaces ($z^{\ell}$ and $(z^{-1})^{\ell}$) and one reduced bracelet ($z^{\ell}$) for all $\ell>0$, so we ignore this case and assume throughout that $g>1$. Obviously, for $g=1$ and $\ell>1$ there are no reduced prime words. The algorithms we give are valid for $g=1$ but they are not CAT, since it takes $O(\ell)$ time to set the word to $z\cdots z$ or to $z^{-1}\!\cdots z^{-1}$.

3 Listing Necklaces

We first need to decide on the conventions we adopt for representing the group generators and their inverses, and how to order these $k$ symbols. Using the integers $\pm 1$, $\dots$, $\pm g$ is straightforward and is convenient for generating and checking inverses. However, it is awkward for running through the symbols in order and checking symbol ordering, since we require a generator to precede its inverse and for $\pm 1$ to precede $+2$, etc. Accordingly, we use the integers [math], $\dots$, $k-1$ with the usual numeric ordering, where even integers $j$ denote the generators and odd integers $j+1$ their inverses.

To handle inverses we introduce the two utility functions areInv() and getInv() of Algorithms 1 and 2. These, respectively, check whether or not two symbols are inverses and return the inverse of a symbol. These functions are common to both the necklace and bracelet algorithms and run in constant time. We separate out these functions for simplicity – in practice they can be compiled as inline functions or replaced by macros.

Our recursive necklace generation procedure genNeck() in Algorithm 3 is now a simple modification of [3, Algorithm 2.1], with the if statements at 9 and 13 ensuring that the prenecklaces remain freely reduced and that the final necklaces are cyclically reduced. For clarity we do not use the guard value $a_{0}$ of [3] and instead use the wrapper code of Algorithm 4. This explicitly sets $a_{1}$ (recording its inverse in $aoi$ to facilitate cyclic reduction checking) and ensures that the prenecklaces at entry to genNeck() are non-empty.

4 Listing Bracelets

Our bracelet algorithm is inspired by that in [13], with reversal of a prenecklace being replaced by word inversion (i.e., reversal and element-to-inverse mapping). The recursive bracelet generation procedure genBrace() and its wrapper code are given in Algorithms 5 and 6, while Algorithm 7 is the checkInv() function for comparing a prenecklace with its inverse. The genBrace() procedure is an augmented version of genNeck(), with the additional code checking each prenecklace (i.e., the putative “prebracelets”) against its inverse and rejecting those that cannot yield bracelets. Thus each rotation of the inverse of the final words is tested, and necklaces which are not bracelets are not generated.

The use of inverses as opposed to reversals actually results in a somewhat simpler algorithm compared with that in [13]. Firstly, note that our order is chosen so that a generator immediately precedes its inverse. This implies that bracelets cannot start with a generator inverse and so these can be skipped in the wrapper code. Secondly, although the checkInv() function can return “equal” as well as “less than” or “greater than” (as does the CheckRev() function in [13]), by Lemma 2.2 it never does so since our preneckaces are always freely reduced. This simplifies the code in the genBrace() procedure, which needs only four parameters compared with the six of GenBracelets() in [13].

The $t$ and $p$ arguments of genBrace() are, respectively, the index of the next position in the array $a$ and the length of the longest prefix of $a$ that is a Lyndon word. The $u$ and $v$ arguments are, respectively, the number of copies of $a_{1}$ at the start of $a$ and the number of copies of $a_{1}^{-1}=aoi$ at the end of $a$, with the initial value of $v$ saved in the local variable $vv$. The code at 9 to 14 and 22 and 25 adjusts $u$ and $v$ as necessary for the next call to genBrace() (if any), using the current value of $j$ (i.e., the next potential value for $a_{t}$) and the current word length $t-1$.

The recursive calls to genBrace() are inside the if-statements of 17 to 20 and 27 to 30. If $u>v$ then the current prenecklace is less than its inverse, so we can immediately call genBrace(). If $u<v$ then the inverse is less than the prenecklace, the prenecklace cannot yield a bracelet, so we do nothing. If $u=v$ then we need to call the checkInv() function to compare the prenecklace with its inverse. If the prenecklace is less we call genBrace(), otherwise we do nothing.

When the checkInv() function is called, the current prenecklace starts with $u$ copies of $a_{1}$ and ends with $v=u$ copies of $aoi$. The remainder, $\gamma$, is non-empty, does not start with $a_{1}$ or end with $aoi$, and is freely reduced. The arguments $t$ and $i$ are the current prenecklace length and the index of the start of $\gamma$. The for-loop compares $\gamma$ with its inverse, returning $-1$ if $\gamma$ (and thus the prenecklace) precedes its inverse and $+1$ if $\gamma^{-1}$ precedes $\gamma$. The upper limit on the for-loop is simply a convenient placeholder – the loop is guaranteed to return $-1$ or $+1$ for some $i\leqslant\lfloor(t+1)/2\rfloor$.

5 Concluding Remarks

We have implemented our algorithms in the C and Magma languages and incorporated them into programs for generating and testing lists of conjugacy classes and presentations. The generation of word lists has proved very fast, with the programs’ running times being dominated by the times to process the necklaces and bracelets in the lists. Empirical evidence (see Appendix A) suggests that our algorithms are CAT, but we have no proof of this.

The genNeck() and genBrace() procedures as given process all reduced necklaces and bracelets. If the “$\ell\bmod p=0$” tests are replaced by “$\ell=p$” then only the reduced aperiodic necklaces (Lyndon words) and bracelets are processed by these procedures.

The recursive nature of our necklace and bracelet algorithms induces a tree structure on their search spaces. These trees can easily be split into subtrees, allowing an enumeration to be parallelised [3] or distributed across a set of heterogeneous machines.

Appendix A Complexity Tests

Implementations of our necklace and bracelet listing algorithms for reduced words in groups have proved very effective. However we have no proof that they run in constant amortized time. Accordingly, in a similar manner to [14, §5 & §6.2.5], we produced experimental results for the amount of work done compared with the number of necklaces or bracelets generated. For these tests the “process … $a_{1}\cdots a_{\ell}$” actions in genNeck() and genBrace() were replaced by code to accumulate the total number of necklaces and of bracelets. These counts were checked against the expected counts from Section 2 and used to calculate the work per necklace and per bracelet data.

The areInv() and getInv() functions are used by both algorithms and are constant time. Each algorithm starts with a for-loop, each iteration of which makes a call to genNeck() or to genBrace(). For necklaces we count the total number of calls, both direct and recursive, to genNeck(). Apart from its embedded for-loop, each call to genNeck() is constant time. So our measure of the amount of work done is the total number of calls to genNeck() plus the total number of iterations of the embedded for-loop across all calls to genNeck(). Figure 1 plots, for various values of the number of group generators $g$, the word length against the ratio of total work to number of necklaces.

For bracelets we count the total number of calls to genBrace() and the total number of iterations of its embedded for-loop. We also need to account for the checkInv() function, which is not constant time. This function is only called if $u$ and $v$ (in genBrace()) are equal, so at least one iteration of checkInv()’s embedded for-loop is guaranteed for each call. Thus, we count the total number of iterations of this loop across all calls to checkInv() and add this to our total. Figure 2 plots, for various values of the number of group generators $g$, the word length against the ratio of total work to number of bracelets.

For both necklaces and bracelets, for all $2\leqslant g\leqslant 6$, the ratio of the total amount of work done to the number of reduced words generated is decreasing (after an initial peak) as the word length increases. This strongly suggests that the algorithms are CAT.