permutations (version 1.0-9)

cyclist: details of cyclists


Various functionality to deal with cyclists


nicify_cyclist(x,rm1=TRUE, smallest_first=TRUE)



Integer vector, interpreted as a word


A cyclist


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


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())


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.

See Also





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)


# }