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.

Pingback: How are permutations independent from arithmetic? (continued) « Csgrouper