Consider a classic (3,8) Euclidean rhythm with a kick and two snares:
"bd ~ ~ sn ~ ~ sn ~"
Wouldn't it be nice to be able to rotate those events through the 3 beats of interest? Something like this:
rotate 1 "bd ~ ~ sn ~ ~ sn ~"
= "sn ~ ~ bd ~ ~ sn ~"
rotate 2 "bd ~ ~ sn ~ ~ sn ~"
= "sn ~ ~ sn ~ ~ bd ~"
rotate 3 = id -- (when applied to a rhythm with three events)
A natural way to do that would be to represent those three moments (that is, 0/8, 3/8 and 6/8) with the first three integers (i.e. 0,1 and 2). By doing that, uneven rotation through the target space (ordinary time) becomes simple addition in the latent indexing space. Index values above two would map to the same times but in later cycles.
As soon as I imagine this being possible, I want to go further, because what if I wanted to index a moment between two of the beats in the grid? For that I would need a second, finer grid to fill in the time between moments in the initial coarse grid. Given those two nested grids, I would need to use a pair of integers to identify moments -- one for the big grid, and one for the points in the small grid between two points in the big grid. I might even want to introduce more than two grids. (Sidenote: Rather than tuples, lists seem like a more convenient way to represent time -- for instance, if there were three nested grids, you could use [1] to represent (1,0,0), [1,2] to represent (1,2,0), etc.)
This idea has bugged me for years, because the music I hear sounds like it was conceptualized this way. Swing is the most common example. You could represent notes in a "swing manifold" by mapping pairs of integers to time, where the second integer can only be 0 or 1. If the second integer is 0, then the pair represents one of the quarter notes, and if the second integer is 1 then it represents a moment roughly two-thirds of a quarter note after one of the quarter notes. Of course real swing is more complex, but it has that flavor.
More generally, in rhythmically interesting music, not all moments are created equal, and it sounds good if every voice cooperates to make certain moments special. Think of Smooth Criminal. Throughout most of that song, every fourth measure starts an eighth-note early. You could program each voice to do that -- but it might be easier to program them all as if they were playing in "straight time", and just warp time underneath them so that what they "think of" as beat 0 is actually beat (-1/8).
An indexing scheme like this would resemble musical scales, but for time rather than frequency. Scales designate a certain set of frequencies as more important than the rest, and make it easy to refer to them by indexing (integer-lookup into) the scale. This kind of nested-dimensional indexing for time might similarly be (at least in some cases) worth it.
I'm hopeful about it in the context of Tidal, because I find it hard to coordinate voices in Tidal. I of course very much enjoy the unpredictable results of a few voices modified by various combinations of fast, slow, (<~), (~>)andrev(to say nothing of compound operations likebrak`). But it can get pretty out of hand pretty quick. Imposing some sort of structure on time as a whole seems like a potentially promising way of reestablishing a little order.
Would you use something like this? What would you like to be able to express? Are there representations that seem more natural to you? Any thoughts would be greatly appreciated!
