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. 


How are permutations independent from arithmetic?

The efficient but complicated definition of a composition of permutations we gave in the code section does not make a point in justifying for the quest of permutational purity. This complicated definition can be reduced to the following lighter formula:

composition[i] = agent[target[i]]

Here the words ‘target’ and ‘agent’ do not mean much in themselves and could be inverted, the idea being just that agent (for instance) should always come first in the described permutation process. We find no evidence for this function to be independent from arithmetic, because its main feature seems to be ordinality, which is central in arithmetic.

This is due to our technical context. Computers do almost everything through arithmetic. However permutations not only escape the realm of order, but can even serve as a foundation for it. What is needed in permutations is not order, nor well order as in our previous definition, but only form.

Take four things: a leaf, a fruit, a stone, a shell. To compute permutations without a machine, you don’t have to know what is their natural order, but decide for a relative position in space and remember it as their original position. No element has to show precedence over another, this is only an arithmetic convenience for machines.

Now just put each one of these elements in the place of another one, and you get your target; remember or draw this too and then change these positions again in another way and you get your agent. For each of these things you can ask what was its position in the original arrangement: stone is where fruit was, shell is where leaf was, etc…


If you need to compose target by agent now, you have to take each element in agent (no matter which one first) and answer two questions instead of one: which is the position of this thing from agent in the original arrangement? for example: – leaf is in the place of fruit. Second question: which is the place of the first answer in our target arrangement? fruit is in target where shell was in the origin. Therefore leaf will be in the composition where shell was in the origin. We didn’t add nor subtract nor multiply nor divide anything at all, nor even take the successor of any element.

If we want we can decide to look  always at our original arrangement according to the same  visual path, first top, then clockwise. Now we have an order and each element has a successor: we just have invented reading and arithmetic at the same time. You can take 0123 for (stone,shell,fruit,leaf) in this order and verify that Compose(3201,1032) is 2310, as showed permutationally.

We have to recognize that – because of its temporal character – music is naturally more arithmetic than permutational, as time succession represents the equivalent of bringing an order of precedence to an arrangement of things.  On the other hand, changing the rules artificially is also what is expected from art.

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];