Using the function Gradual(Omap())

The function of Mapped Opposite enables the musician to choose among sets of series sensitive to their permutational properties (Cf. J.Palfi et al., 2008, Le dodécaphonisme comme outil d’analyse – in French).

To say things quickly, the mapped opposite uses what group theory calls an invariant, in order to have a suite transposed permutationnally. If you do the gradual suite of the opposite of any series S, mapped onto S, you get a suite G that is the same for each transposition of S. Now if you unmap each element of G from S+1 you get a transposed suite Q+1, and you can get Q+2 by unmapping G from S+2. Capisce?

(the command lines below can be sent from the Series tab)

print Csgrouper::Gradual(Csgrouper::Omap(“32014″),’a’)
   12340 23401 34012 40123
# The gradual suite made upon the mapped opposite of 32014.

print Csgrouper::Gradual(Csgrouper::Omap(Csgrouper::Transpose("32014","00000",1,5,'')),'a')
   12340 23401 34012 40123 
# We see that however transposed, the result is the same.

print Csgrouper::Gradomap("32014",'a')
   20143 01432 14320 43201 
# This is the gradual suite made of the mapped opposite, where each row has been unmapped from 32014.

print Csgrouper::Gradomap(Csgrouper::Transpose("32014","00000",1,5,''),'a')
   31204 12043 20431 04312
# Here each row from the previous suite is transposed, permutationally.

The only thing to care about is that these gradual suites – as they are produced by Gradomap() in the Csgrouper sequence creation process (and not as in here with the command line) – will contain an additionnal row in the beggining, which is  the original row S itself, or S+n if transposed. This allows us to keep in touch with our starting point musically, and it is not unsound permutationally, since S is the last element in the cyclic suite (we could have made it last too). The difference, with normal, not unmapped, Gradual suites – which contain one row less – comes from the fact that in normal Gradual suites, as in the above example, Csgrouper does not add the last element which is always equivalent to Natural(S) i.e. the chromatic scale (for this has rarely a nice effect in music).


In the preceding example Gradual(Omap(S)) is the original function without unmapping, unlike Gradomap(S) which proceeds to the unmapping. However, in Csgrouper’s Sequence Details tab, where one can choose functions by menu, the menu item Gradual(Omap(S)) implies automatic unmapping and in fact calls internally Gradomap(). This is due to the fact that musically speaking, Gradomap() is much more interesting as it yields transposed suites. If a user wants to create a bare Gradual(Omap(S)) as above, she will have to do it through command line from the Series tab and then paste the result as a Suite() into the chosen Sequence window. So all this naming is fallacious, and I should have named the menu item Unmap(Gradual(Omap(A)),A) and Gradomap() Ugradomap() or something. 



Non permutational serialism (3): What about Schoenberg ?

According to Milton Babbitt [1], Schoenberg’s twelve tone musical system is permutational. However Babbitt’s maths are so hard to understand for me that I seem condemned to believe this claim because of my ignorance. Even in religion this wouldn’t be the right way to believe, so we are going to ask the question about the permutational nature of Schoenberg’s musical theory in a way that makes sense to us (non mathematicians).

The basic schoenbergian material is quite narrow, it is made of 4 expressions, or instances, of the same twelve tone row. If we call S one series of notes chosen among the 479001600 rows made of 12 distinct digits, then Schoenberg admits also the same row read from right to left and he calls this instance of the row its retrograde form, or sometimes also its recurrence. We are going to choose the term ‘reverse’ to name this instance of S, and choose the letter R to design it. The third form used by Schoenberg was called a reversal but consisted in taking the inversion of each interval in the row, so we are going to call it ‘inverse’ and abbreviate it ‘I’. The last traditional form in twelve tone music was sometimes called recurrence of the reversal, but it will be clearer to describe it reverse of the inverse, according to the previous naming since it is only the inverse read from right to left, and we will call it ‘opposite’ or simply ‘O’.

Let’s take a random example:

S : 87925361A04B
R : B40A16352978
I : 453A796B2081
O : 1802B697A354

We can verify that R is S read from right to left, as well as O for I. And this reverse form is indubitably permutational because it is obtained easily  by composing S (or I) with the last element of the well ordered permutational set which is BA9876543210. [2]

Now if we look at I, things are not so clear, we can obtain it by taking the inverse value of each note, for example if the first note is 8 (G#) then we take 8 steps down starting at 0 (C) and that is 4 (E), etc. for each other note. But this way of doing is not permutational, it’s arithmetic. In fact for each possible S, there is one precise composed row that will get I, and many different rows will get their inverse by being composed with the same row so there is a whole subset of the total group of permutations that play for I the role BA9876543210 was playing for R .

This set of 10395  inverting rows in base 12 separates the total set of permutations in subsets of 46080 rows. All the 10395 share a common type [3], which is the type of their most remarkable – and last – element : 0BA987654321. [4] We see that having 0 on its index has the result of setting the axis on this note. I don’t know if Schoenberg always chose that note as axis, but if he did then it was an undue priviledge; in Csgrouper one can choose any index as axis by setting the ‘x’ field.

Which further permutational means can make us select the correct row to compose with S in order to obtain I, that’s what I’d like to know; it is perhaps also something Babbitt had explained to the graduates, who knows?


[1] Milton Babbitt, 2003, Collected Essays, Princeton University Press.

[2] See the definition of a composition of rows in the ‘code’ section.

[3] See the definition of the type of a row in the ‘code’ section.

[4] There are for instance 46080 rows whose Inverse can be produced by composing them with  0BA987654321, and 10394 other inverting rows like 0BA987654321 with their 0 in indexical position. If we agree to have each note in turn in indexical position and produce this way 12 different inverses for each row, we obtain a set of 124740  inverting rows, among 479 millions.

Update 130607:

Addition and correction

We don’t have to check 479 millions permutations to catch those values; as many results about permutations they come from induction:

a)- note that in many bases (B+1) many inverses are produced by the inverting row 0B..1 and call this row T[B+1];
b)- check the small bases first to see how many inverses are produced by T[B] and call this number N[B];
c)- remark that B!/N[B] = the total number of inverting rows, call it R[B];
d)- for the same value of R, bases go by pairs (even then odd), the other mentionned values always differ in a higher base;
e)- observe that B*R[B] = R[B+1] but only when B is odd;
f)- so  N[B+1] = (B+1)!/(B*R[B]) =  (B+1)!/(B*R[B-1]); when B is odd;
g)- and R[B] = (B-1)*R[B-1] = (B-1)*R[B-2]; when B is even;

For example:

e) 3*1 = 3 = R[4]; 
f) 4!/3 = 8 = N[4]; 
e) 5*3 = 15 = R[6]; 
f) 6!/15 = 48 = N[6]; 
e) 7*15 = 105 = R[8];
f) 8!/105 = 384 = N[8];
e) 9*105 = 945 = R[10];
f) 10!/945 = 3840 = N[10];
e) 11*945 = 10395 = R[12]; 
f) 12!/10395 = 46080 = N[12];


Non permutational serialism (2): Static and dynamic intervals

Though it is permuting notes, the function Train() is not ‘permutational’ because it does not compose permutations but only iterate through the notes of some series in order to modify the corresponding values in another one. This could certainly be done ‘permutationally’ but with much more computation and it’d be useless in this context, since the goal of this set of functions is precisely to obtain sequences different from typical permutational ones. With Trainsposition() we had an already interesting example since each modifying note was given two parameters (in addition to its index): an integer value and a sign. The amount of strictly permutational manipulations needed to perform such a computation would be fairly large.

Static intervals

Now instead of applying one modification to each note in a series and take a picture of the result after each step in the process, we want to have a sequence of intervals (they can be represented by a series too) that will run through our original series and stop at some stage. Each interval will be applied to a gradually decreasing number of notes in the original row. Let’s name ‘origin’ the series to be modified. The number of concerned notes in the origin is decreasing because each time an interval has reached the last available note, is remains as a permanent modification. So for a twelve-tone origin, as soon as the first interval has reached the last note, it remains there and this note index is not available anymore for further modification. Then the second interval only touches eleven notes in the origin, and so on till the last change which only concerns one note. This is a train of static intervals.

These schoenbergian examples are taken from a 2008 Etude for clarinet.

Series S:   05814B62793A
Reverse R:  A39726B41850
Inverse I:  074B816A5392
0pposite O: 2935A618B470

Ex. 1:

*** DESCR: seq_obj: Seq_2 after Build_tree: object tree: 
funt: Static(A=05814B62793A,oct,B=A39726B41850,oct,ord=05814B62793A) ready: 1 ***
*** seq_proc : Tkrow_2 Sequence object: recorded

In this sequence we reach at step 12 the schoenbergian Reverse of Series S. The notes are modified following the order given by the same Series S. Now we could be interessed by the series of intervals that is applied in this case. To acquire this knowledge, Csgrouper provides – on the ‘Series’ tab – an analytic function called Statana(). Putting our origin (05814B62793A) into fields A and ord and our target (A39726B41850) into field B and applying function Statana() we obtain the resulting series (261215A2265A) and a sequence of signs (++-+++—–+) that have to be applied to S in order to get R under the static intervals sequential method. You can verify that the first value (2) has to be added (+) to note index (A=10, i.e. the eleventh note in S = 3) in order to get (5) which is the eleventh note in R. To get there, (2) had first to change the value of each other note in S. This knowledge isn’t required to run Static() though, but the same sequence of values can then be devoted to another role somewhere else in a work for instance.

Dynamic intervals

Now we can also have our origin modified permanently by each interval. Instead of falling back to the original value when a note has been modified, we keep the modified value. Then next time the interval changes this note, it is no more the value that was shown in the origin. This is a train of dynamic intervals, and it almost makes melodies sound like random sequences. However, the ultimate state of the series is completely determined too. Thus sequences of dynamic intervals are useful in music because from an original pattern they create complications leading to other defined musical patterns. The complication itself shows properties that the ear may perhaps sometimes apprehend or recognize, most of all when this form is used in several places in a piece. Again the internal parameters of Dynamic() can be known by feeding the same fields and appying Dynana() (checking the box ‘exp’ will further expand the results).

Ex. 2:

Now we start from where we left off in Static(), i.e. R (A39726B41850) and we want to reach O (2935A618B470) according to order (A39726B41850):

*** DESCR: seq_obj: Seq_2 after Build_tree: object tree: 
funt: Dynamic(A=A39726B41850,oct,B=2935A618B470,oct,ord=A39726B41850) ready: 1 ***
*** seq_proc : Tkrow_2 Sequence object: recorded

Non permutational serialism (1): Trainsposition()

Aside from what is explained in the ‘code’ section, Csgrouper offers non permutational functions, that were the origin of the whole program back in 2008. Their purpose is to transform gradually one series to another by arithmetic means.


While mere ‘Transposition’ is easily replaced by setting the correct ‘tone’ value for a ‘Suite’ in the corresponding row (and could therefore be removed from the function menu if it wasn’t for the possibility of giving a negative interval value to the field ‘n’),  ‘Trainsposition’ represents the first in a set of non permutational functions I wish to describe here. However there is a last semi-permutational function to describe before, because it makes the link between permutational and non permutational functions by giving to the latter ones a general action scheme.


The Train function is quite simple, provided you give it two Series, no matter whether they are made of distinct elements, and one Order Series, all three in the same base, it will yield a gradual replacement of the values of the first one by the values of the second one following the indexical order given as third series.

The Order Series (ord) must be made of distinct elements, and that feature is shared by all Train-like functions explained from now on.


*** DESCR: seq_obj: Seq_1 after Build_tree: 
object tree: 102145 112145 111145 111145 111115 111111
funt: Train(A=302145,oct,B=111111,oct,ord=012345) [n=1] ready: 1 
*** seq_proc : Tkrow_1 Sequence object: recorded

This last example taken from the output in Csgrouper’s terminal after row validation, shows well the process that will be shared by all non permutational functions. The original Series sees its first element replaced by the corresponding element in B, and so on till the whole Series is replaced (here the repetitions come from the fact that we have chosen a replacing Series made of one sole element) . Now if we had put 3 into field ‘n’ we’d have obtained:

object tree: 111145 111110

And this is a (small) bug since last sign should be one! But we see that the number of intermediary series made by the train is different. This feature will be further described below.


This function will take a Series (A) as first argument (a twelve-tone row in our example) and transpose each of its notes according to the values in a second Series (B) in the same base. This transposition will however not be done at once but note by note, so if the Series has twelve notes, it will then be repeated twelve times, each time showing a new differing note till reaching a totally different Series, possibly with non-distinct signs. This behaviour makes the ear gradually used to a different note pattern.

To make things a little less predictable, we add three factors to our transformation: first, the order in which the notes are taken for transposition is not necessarily ascending but represented by any Series in the same base put into field ‘ord’. Second, unlike normal transposition, the  value combined with the original note is not necessarily unique, i.e. you can have a different transposition value for each note of your base Series. This is the content of field (B). Of course you can also choose to have the transpositions done with a sole value, then your field (B) should be filled with 12 times that value, for example, ‘111111111111’ will transpose all your original row one semitone higher. The third factor is the sense of transposition, and it will define whether you’d like to have your transposition value added or subtracted from your original note. This is the content of field ‘signs’ and it be filled with signs corresponding to the values in field (B). For example ‘-+++++++++++’ will make the function subtract from your initial note, and then add to the other ones.

Another way of modifying the behaviour of this function is to change the value of the field ‘n’ to one of the divisors of your Series base. For a twelve-tone row we see that this value can be set to 1, 2, 3, 4 or 6. Each one of these choices will have the effect of grouping together as many changes or steps in the gradual process. Having 3 in ‘n’ for instance, will limit the repetitions of a twelve-tone row to 4, each one containing 3 notes transposed. This value is also set as a global fallback value for each row by meta-field ‘Steps’, but the utility of this field raises a question: to be efficient in each possible case, it should always be set to one (because a series base can be a prime number) and thus it isn’t requiring an independant field.

Unfortunately – unlike what exists for the Static and Dynamic trains of intervals we’ll examine later –  Csgrouper doesn’t provide any analytic tool to tell quickly which Series of transpositions (B) you have to use in order to obtain a certain Series as last output of this function, but this is not very difficult to calculate.

Finally as with any Series manipulation in Csgrouper, one has to be aware of the octavial range attributed jointly (correlative fields ‘Aoct’ and ‘Boct’).

Roots of permutations (continued)

The method we described works well for small bases but as soon as we try to find roots of a dodecaphonic sequence, it reveals insufficient. I realised this working on the row “A0B281947356” which is what dodecaphonists called an “Alleintervallenreihe”. Its elementary partition is (“A510”, “B6932”, “874”) and we see immediately that no lower partition can produce by division such uplets, therefore the roots of “A0B281947356” have to share the same type.

Now as a partition containing an odd uplet is accompanied by a mirror of itself in the same cycle and as a mirror is a root for its reflection, we can suppose that the mirror of our row is one of its roots. It is easy to verify that the permutation corresponding to uplets (“15A0″,”396B2″,”784”) contains “A0B281947356” within its cycle (this is even easier to verify using the scripts provided  in the Code section).

We can vary the composition of uplets choosing one uplet in the original row and one in the mirror – respecting correspondence in subsets of digits – as we did above, mutatis mutandis, when we varied the order of figures in a root partition in order to discover new roots.

This way we find easily among the 480 millions permutations in base 12 a small subset of 8 partitions working as roots for our Alleintervallenreihe:

  1.  (“A510”, “B6932”, “874”) : “A0B281947356”
  2.  (“A510”, “B6932”, “784”) : “A0B271984356”
  3.  (“A510”, “396B2”, “874”) : “A03981B47652”
  4.  (“A510”, “396B2”, “784”) : “A03971B84652”
  5. (“15A0”, “B6932”, “874”) : “15B28A947306”
  6. (“15A0”, “B6932”, “784”) : “15B27A984306”
  7. (“15A0”, “396B2”, “874”) : “15398AB47602”
  8. (“15A0”, “396B2”, “784”) : “15397AB84602”

It is nice but will it suffice? Unfortunately not. As long as we don’t reach a deeper comprehension of permutations we risk to miss some source for our roots. Now we could simply rely on the idea of complete cycle (A3) and test each one of the 60 members of our suite, but suppose that for non-musical purpose we were searching roots of a much higher base, then this test itself would reveal prohibitive. As we’re about to find some way of doing what we want in base 12, we can still ask ourselves if we didn’t leave some other cases apart: being reluctant to dive into group theory has a cost.

However, let’s finish with this imperfect method.

What really are n-tuples?

We can see our n-tuples as subsets of binary permutations. This way they can be read in one direction or the other so as to describe what happens to our natural row (“0123456789AB”) in order to become our permutation (“A0B281947356”). In the elementary partition of this last row  (“A510”, “B6932”, “874”), we can read the first uplet from right to left as “0” takes the place of “1”, “1 takes the place of 5”, “5 takes the place of A”, “A takes the place of 0”.

Dancing a round

This  description of the relation between our rows reminds me of a nice illustration of algorithm with Hungarian folk dancers. We can also say that this is one manner for each sign in this uplet to be located at the right of another sign: “0 is at the right of 1”, “1 is at the right of 5”, etc.. And we have to consider these signs as dancing a round and it is indeed a useful addition that can be made to our method in order to get all the roots. For if we require from each sign in each uplet to be at least one time in one uplet placed at the right of each other sign from the same original subset, then we get all our roots.

Roots of permutations


What are the various cyclic permutational suites containing a given permutation of distinct elements? This question has some importance in serial music where permutations can then be chosen according to their ability to lead to one another by means of their cyclic suites. I present a method below that could perhaps be refined for an automated algorithm. It’s however not straightforward enough to be expressed in code at this stage. Any suggestion will be most welcome in this perspective. Examples in this post are made with the help of scripts provided in the Code section of this blog.


I. Definitions

D0 The B Set. There are b figures available in base b, from which are made b! permutations of distinct elements (also called series), components of the B set.
$./permute 012
Computing permutations of 012 .. (Psiz=3)
6 permutations done in 0.00 s.

D1 Cycle. A cycle C is the cyclic suite stemming from a given permutation p of distinct elements.
$ ./ 2130 1
2130 3102 0123

D2 Power. The power of any permutation is its position in a cycle.
$ ./ 2130 2130

D3 Root. For each permutation in a cycle, the permutation of power 1 is called the root.

D4 Natural Series. The natural series S is the last permutation in each cycle. It is simply the ordered list of signs used by a permutation in the corresponding base b.
$ ./ “2130” 1
2130 3102 0123

D5 Degree. The degree of a permutation p is the number of permutations contained in the cycle of which p is the root.
$ ./ “2130”

D6 Partition. The partition (or elementary partition) P of a given permutation p is made of disjointed subsets of signs of S permuted in p and called “uplets”. The smallest of these subsets are singletons (designing occurences of non permuted signs). The order of elements of a partition is irrelevant. What qualifies a permutation p qualifies also most of the time the corresponding partition P, mutatis mutandis (for example, a partition will be said higher or lower in a suite according to the power of the corresponding permutation).
$ ./ 2130
230 1

D7 Uplet. An uplet (n-uplet, n-tuple), is a subset in a partition (usually greater than a singleton). An uplet represents a specific chain of independent binary substitutions which is not alteredd by other permutations applied to S in order to end in a permutation p. An uplet U1 higher or lower than an uplet U2 is an uplet whose signs pertain to U2, element of a partition repectively higher or lower.

D8 Pair. A pair is an uplet of 2 signs.

D9 Term. The term is the last sign in an uplet.

D10 Prime Cycle. A prime cycle C is a cycle whose root partition is a single uplet showing the cardinality of a prime number; C contains each root of each of its member permutations and excludes other permutations.
$ ./ 5264013 1
5264013 1630524 2345160 6401235 3052641 4516302 0123456

D11 Miror. The miror of a partition P in a cycle is a partition containing the same uplets as P, but in each one, the chain of signs preceding the term is reversed.
$ ./ 4516302
$ ./ 5264013

D12 Type. The type T of a partition P is a description of the content of P in size and quantity of its uplets. A type T1 is said higher than a type T2, as soon as appears in T1 starting from the right, a figure greater than its value in T2.
./ 1645230


II. Observed regularities (taken as postulates)

A0 Relation between partitions and the root. There is a relation of transformation between the uplets of a root partition and the uplets of higher partitions in the cycle. Each uplet of the root can only be transformed in equal uplets of lower cardinality or remain the same. The uplet is divided by the greatest divisor common to its number of signs and the power of the partition.

A1 Permanency of singletons. Singletons of a root partition remain identical in all permutations of a cycle.
$ ./ 3125064 1
3125064 5126340 6124503 4120635 0123456
$ ./ 3125064
35640 1 2
$ ./ 5126340
54360 1 2
$ ./ 6124503
63450 1 2
$ ./ 4120635
46530 1 2
$ ./ 0123456
0 1 2 3 4 5 6

A2 Transformation of pairs. Pairs of a root partition are split in singletons in each partition of the cycle with an even power.

A3 Complete Cycle. The cycle of a permutation p whose root shows the same type as p, contains the total set of permutations involving p in their cycles. This is namely the case of prime cycles.
Ex.: see Example 3 below.

A4 Types and the root. The type of a partition can only be equal or lower than the type of its root.

A5 Criterion of the mirrors. A partition endowed with an odd uplet or a single uplet is always accompanied by a mirror of itself within the same cycle.

A6 Uplet Translation. Each uplet is equivalent to one of its horizontal translations.

A7 Term of an uplet. There is always a higher uplet showing (possibly after translation) the same term as its lower uplet in the root.

A8 Power Index. When the term of a first uplet in a root is chosen as equivalent to the term of a first uplet in a higher partition (by A6 and D5), then the figure located at the index of the power of the higher permutation, in the root is the same as the first figure in the higher uplet.

A9 Transitivity. If a root P1 contains a partition P2 within its cycle then the root of P1 contains P2 within its own cycle too.

A10 Reflexivity. Each permutation is a root for itself.

A11 Symetry. A mirror is a root for its reflection.


III. Application

Example 1

1.0 Statement
We are searching the roots of permutation p = 43012 whose partition P = 420 31 and type T = 01100.

1.1 Determine the type of roots
Each uplet of a root can only be divided in equal parts in a higher partition, therefore, p having an odd base, a root of a single uplet can’t stand below P. (A0)
Neither can P be partition of power 2, because then:

  •   its root r should contain a 4-uplet and a singleton but this is impossible due to (A1)
  •   or r should contain a pair but this is impossible due to (A2)

Finally as the type of a root can only be greater or equal to the type of a higher partition, we find that P shares the type of its roots. (A4)

1.2 Find the roots
It suffices here to find the other member of the cycle of p, due to (A3). We could also proceed with the method shown in example 2 and that would illustrate A3.

1.3 Verification

./ "01234" "0" "43012" "gradual"
Gradual suite of 23410 contains 43012 and its elementary partition is: 240 31
Gradual suite of 43012 contains 43012 and its elementary partition is: 420 31

Example 2

2.0 Statement

Find roots of permutation p = 104523 whose partition P = 10 42 53.

2.1 Find the types of roots
As each uplet of a root can be divided in equal parts in a higher partition, P being made of equal parts, there exist one or several roots of P differing from P. (A1)
An obvious root of P is made of a 6-tuple. But this root can’t precede immediately p because 3 is not a common divisor of 6 and 2. Therefore p’s power is a multiple of 3 and its root partition is made of a single uplet (or identical to itself). (A0,A2)
But p’s power can’t be greater than 3 because 4 and 5 are not multiples of 3 and 6 leads to the end of any cycle whose root is a single 6-tuple.

2.2 Find the roots
As on one hand there is always a lower uplet showing the same term as its root uplet and on the other hand a single uplet root is candidate to permutations that are not translations, one can infer that there are several 6-tuple roots for p. (A7,A6,A12)
As each root contains 0 and every root equals its horizontal translation, one can choose 0 as term for every 6-tuple root and 10 as first uplet of P. (A6,D5)
Then for each 6-tuple root, 0 is the last figure and 1 the third. (A7,A8)

We draw 6 empty boxes corresponding to the figures in our 6-tuple. We start by the the first known figure which is 1 and place the term of our 6-tuple. Then we jump to the third box to the right (3 being our root uplet divisor), starting again from left as needed, except if our last figure was the term of any uplet in P. In these last cases we don’t fill the third box but the next one:


  1. ######
  2. ##1### (by A8) now from 1 we jump over the last 3 boxes,and take the next figure in P, i.e. 0, to fill the next box i.e. the last one:
  3. ##1##0 as 0 was chosen as term we knew that already…
  4. 4#1##0 as our last figure was a term we didn’t jump this time;
  5. 4#12#0 4 was not a term so we wrote 2 in the third box to the right of it;
  6. 4#1250 2 was a term so we didn’t jump and wrote 5 next to it;
  7. 431250 last jump and we’ve got a first root, let’s call it P2 (as P1 equals P by A10);

(Beware: this is not a permutation, but a partition, the corresponding permutation being 425130).
The other roots in this subset are easier to define since we know that they’re all made of 6-tuples. They will appear with the same method, varying the order of figures (horizontal translations) and uplets in P. We just keep one stable uplet in P, the first one, ensuring the horizontal coherence of the resulting partitions.

R3: As R2 but translating the 2nd pair: (A6)
##1##0 > 2#1##0 –> 2#14#0 > 2#1450 –> 231450 = R3
R4: As R2 translating the 3d pair: (A6)
##1##0 > 4#1##0 –> 4#12#0 > 4#1230 –> 451230 = R4
R5: As R2 but translating the 2nd and 3d pairs: (A6)
##1##0 > 2#1##0 –> 2#14#0 > 2#1430 –> 251430 = R5
R6: As R2 but changing the order of pairs: (D5)
##1##0 > 5#1##0 –> 5#13#0 > 5#1340 –> 521340 = R6
R7: As R2 but changing the order of pairs: (D5)
##1##0 > 3#1##0 –> 3#15#0 > 3#1540 –> 321540 = R7
R8: As R3 but changing the order of pairs: (D5)
##1##0 > 5#1##0 –> 5#13#0 > 5#1320 –> 541320 = R8
R9: As R3 but changing the order of pairs: (D5)
##1##0 > 3#1##0 –> 3#15#0 > 3#1520 –> 341520 = R9
To these 8 root partitions can we add partition P as R1 because any permutation is its own root. This makes a set of 8 roots for p. (A10)

2.3 Verification

$ ./ "012345" "0" "104523" "gradual"
Gradual suite of 104523 contains 104523 and its elementary partition is: 10 42 53
Gradual suite of 243150 contains 104523 and its elementary partition is: 231450
Gradual suite of 245031 contains 104523 and its elementary partition is: 251430
Gradual suite of 350412 contains 104523 and its elementary partition is: 341520
Gradual suite of 351204 contains 104523 and its elementary partition is: 321540
Gradual suite of 423051 contains 104523 and its elementary partition is: 451230
Gradual suite of 425130 contains 104523 and its elementary partition is: 431250
Gradual suite of 530214 contains 104523 and its elementary partition is: 541320
Gradual suite of 531402 contains 104523 and its elementary partition is: 521340

Example 3

3.0 Statement
Find roots of permutation p = 5264013 whose partition is P = 5126340.

3.1 Find the types of roots
Here we have a single uplet in a prime base, thus it’s a prime suite with 6 roots. (D10,A3)

3.2 Find the roots
We can simply trust A3 or rebuild the various roots with the same method as above:
As P has power 2, 5 will be put in second place, i.e. at index 1, and 0 will be the term of the uplet:

(5126340) -> R2 skipping 1:
#5##### -> #5#1### -> #5#1#2# -> 65#1#2# -> 6531#2#-> 653142#-> 6531420 = R2
As there is no further uplet to treat we can’t find new roots varying the order or horizontally translating the uplets. However as the root of a root of p contains p too, we can try to find the other roots recursively this way:

(6531420) -> R3 skipping 1:
#6##### -> #6#5### -> #6#5#3# -> 16#5#3# -> 1645#3#-> 164523#-> 1645230 = R3
(1645230) .. etc.
The simplest way with a prime root remains to extract the contents of its gradual suite directly:

$ ./ ” 5264013″
5264013, 1630524, 2345160, 6401235, 3052641, 4516302, 0123456

3.3 Verification

./ "0123456" "0" "5264013" "gradual"
Gradual suite of 1630524 contains 5264013 and its elementary partition is: 1645230
Gradual suite of 2345160 contains 5264013 and its elementary partition is: 2413560
Gradual suite of 3052641 contains 5264013 and its elementary partition is: 3254610
Gradual suite of 4516302 contains 5264013 and its elementary partition is: 4362150
Gradual suite of 5264013 contains 5264013 and its elementary partition is: 5126340
Gradual suite of 6401235 contains 5264013 and its elementary partition is: 6531420

Example 4

4.0 Statement
Find the roots of p = 0125346 whose elementary partition P = 0 1 2 543 6

4.1 Determine the types of roots

Step 1:
If P is a partition of power 2:
The root can’t contain two 3-tuples as one 3-tuple power 2 cannot become singletons this way. (A0)
The root can’t contain a 6-tuple either. (A0)
The root can only have groups of pairs and one 3-tuple. (A0)
Possible groups of pairs: (01,26) ou (12,06) ou (16,20) (A6)

Step 2:
At second stage the roots found this way will be shown to contain p in their gradual suites too. (A9)
These roots can afford a further 4-tuple plus a 3-tuple but the base does not permit lower rooting.
Finally we can postulate that a partition containing an odd uplet entails always a mirror partition in the gradual suite and this makes a new root because a mirror is always a root for its reflection. This adds one root to the set. (A5,A11)

4.2 Find the roots

Step 1:
3-tuples + pairs:
We can choose to place the 3-tuple in head of P and keep the term as 3:
R2: #5# > 45# > 453 …
let’s choose 2 pairs: 01 and 26:
453 01 26 = R2 et so with the 2 other groups of pairs: 453 12 06 = R3 et 453 16 20 = R4.

Step 2:
Each root in step 1 can be the power 2 in a suite whose root is made of a 4-tuple and a 3- tuple. (A0,A12)
Suppressing unuseful translations there remains the following possible 4-tuples:
0126, 0162, 1026, 1062, 1206, 1260, 2106, 2160, 1620, 1602, 6120,6102, in other words each group of pairs generates n/2*(n/2)! valid uplets, here 12. . (A0,A12)

Step 3:
One can now rely on partitions. Their suites will contain the wanted permutation:
For each 4-tuple we’ll get two partitions corresponding to the mirrors of 543, and this makes 24 different roots to which we can add the 3 groups of pair, multiplied by their own mirrors = 6 additional roots, plus p and its mirror = 32 roots.

4.3 Verification

./ "0123456" "0" "0125346" "gradual"
Gradual suite of 0124536 contains 0125346 and its elementary partition is: 0 1 2 453 6
Gradual suite of 0125346 contains 0125346 and its elementary partition is: 0 1 2 543 6
Gradual suite of 0164532 contains 0125346 and its elementary partition is: 0 1 62 453
Gradual suite of 0165342 contains 0125346 and its elementary partition is: 0 1 62 543
Gradual suite of 0214536 contains 0125346 and its elementary partition is: 0 21 453 6
Gradual suite of 0215346 contains 0125346 and its elementary partition is: 0 21 543 6
Gradual suite of 0624531 contains 0125346 and its elementary partition is: 0 61 2 453
Gradual suite of 0625341 contains 0125346 and its elementary partition is: 0 61 2 543
Gradual suite of 1024536 contains 0125346 and its elementary partition is: 10 2 453 6
Gradual suite of 1025346 contains 0125346 and its elementary partition is: 10 2 543 6
Gradual suite of 1064532 contains 0125346 and its elementary partition is: 10 62 453
Gradual suite of 1065342 contains 0125346 and its elementary partition is: 10 62 543
Gradual suite of 1264530 contains 0125346 and its elementary partition is: 1260 453
Gradual suite of 1265340 contains 0125346 and its elementary partition is: 1260 543
Gradual suite of 1604532 contains 0125346 and its elementary partition is: 1620 453
Gradual suite of 1605342 contains 0125346 and its elementary partition is: 1620 543
Gradual suite of 2064531 contains 0125346 and its elementary partition is: 2610 453
Gradual suite of 2065341 contains 0125346 and its elementary partition is: 2610 543
Gradual suite of 2104536 contains 0125346 and its elementary partition is: 20 1 453 6
Gradual suite of 2105346 contains 0125346 and its elementary partition is: 20 1 543 6
Gradual suite of 2604531 contains 0125346 and its elementary partition is: 20 61 453
Gradual suite of 2605341 contains 0125346 and its elementary partition is: 20 61 543
Gradual suite of 2614530 contains 0125346 and its elementary partition is: 2160 453
Gradual suite of 2615340 contains 0125346 and its elementary partition is: 2160 543
Gradual suite of 6014532 contains 0125346 and its elementary partition is: 6210 453
Gradual suite of 6015342 contains 0125346 and its elementary partition is: 6210 543
Gradual suite of 6124530 contains 0125346 and its elementary partition is: 60 1 2 453
Gradual suite of 6125340 contains 0125346 and its elementary partition is: 60 1 2 543
Gradual suite of 6204531 contains 0125346 and its elementary partition is: 6120 453
Gradual suite of 6205341 contains 0125346 and its elementary partition is: 6120 543
Gradual suite of 6214530 contains 0125346 and its elementary partition is: 60 21 453
Gradual suite of 6215340 contains 0125346 and its elementary partition is: 60 21 543