permutations (version 1.0-9)

# cyclist: details of cyclists

## Description

Various functionality to deal with cyclists

## Usage

```vec2cyclist_single(p)
vec2cyclist_single_cpp(p)
remove_length_one(x)
cyclist2word_single(cyc,n)
nicify_cyclist(x,rm1=TRUE, smallest_first=TRUE)```

## Arguments

p

Integer vector, interpreted as a word

x,cyc

A cyclist

n

In function `cycle2word_single()`, the size of the permutation to induce

rm1,smallest_first

In function `nicify_cyclist()`, Boolean, governing whether or not to remove length-1 cycles, and whether or not to place the smallest element in each cycle first (non-default values are used by `standard_cyclist()`)

## Details

A cyclist is an object corresponding to a permutation P. It is a list with elements that are integer vectors corresponding to the cycles of P. This object is informally known as a cyclist, but there is no S3 class corresponding to it.

An object of S3 class cycle is a (possibly named) list of cyclists. NB: there is an unavoidable notational clash here. When considering a single permutation, “cycle” means group-theoretic cycle; when considering R objects, “cycle” means “an R object of class cycle whose elements are permutations written in cycle form”.

The elements of a cyclist are the disjoint group-theoretic cycles. Note the redundancies inherent: firstly, because the cycles commute, their order is immaterial (and a list is ordered); and secondly, the cycles themselves are invariant under cyclic permutation. Heigh ho.

A cyclist may be poorly formed in a number of ways: the cycles may include repeats, or contain elements which are common to more than one cycle. Such problems are detected by `cycle.valid()`. Also, there are less serious problems: the cycles may include length-one cycles; the cycles may start with an element that is not the smallest. These issues are dealt with by `nicify_cyclist()`.

• Function `nicify_cyclist()` takes a cyclist and puts it in a nice form but does not alter the permutation. It takes a cyclist and removes length-one cycles; then orders each cycle so that the smallest element appears first (that is, it changes `(523)` to `(235)`). It then orders the cycles by the smallest element.

• Function `remove_length_one()` takes a cyclist and removes length-one cycles from it.

• Function `vec2cyclist_single()` takes a vector of integers, interpreted as a word, and converts it into a cyclist. Length-one cycles are discarded.

• Function `vec2cyclist_single_cpp()` is a placeholder for a function that is not yet written.

• Function `cyclist2word_single()` takes a cyclist and returns a vector corresponding to a single word. This function is not intended for everyday use; function `cycle2word()` is much more user-friendly.

• Function `char2cyclist_single()` takes a character string like “`(342)(19)`” and turns it into a cyclist, in this case `list(c(3,4,2),c(1,9))`. This function returns a cyclist which is not necessarily canonicalized: it might have length-one cycles, and the cycles themselves might start with the wrong number or be incorrectly ordered. It attempts to deal with absence of commas in a sensible way, so “`(18,19)(2,5)`” is dealt with appropriately too. The function is insensitive to spaces. Also, one can give it an argument which does not correspond to a cycle object, eg `char2cyclist_single("(94)(32)(19)(1)")` (in which “9” is repeated). The function does not return an error, but to catch this kind of problem use `char2cycle()` which calls the validity checks.

The user should use `char2cycle()` which executes validity checks and coerces to a cycle object.

`as.cycle`,`fbin`,`valid`

## Examples

```# NOT RUN {
vec2cyclist_single(c(7,9,3,5,8,6,1,4,2))

char2cyclist_single("(342)(19)")

nicify_cyclist(list(c(4, 6), c(7), c(2, 5, 1), c(8, 3)))
nicify_cyclist(list(c(4, 6), c(7), c(2, 5, 1), c(8, 3)),rm1=TRUE)

cyclist2word_single(list(c(1,4,3),c(7,8)))

# }
```