I had an idea for a new piece of music based loosely on the idea of data caching in computer systems, and on the idea of mutual recursion.

I will spend time formally describing the piece in a future post, but the high-level idea is this:

Emitters.  There is a set of ‘emitters’.  These are abstract, and could be humans or groups of humans or whatever.  An emitter is, abstractly, an list of values ordered from oldest to newest.  Each emitter is initialized to some arbitrary initial sequence, where the values in the sequence fall within the range [0, …, L], and L is the length of emitters’ sequences.  The number of values an emitter contains is arbitrary, but must be the same for all emitters.

Time and Triggering.  Each emitter also has a time interval associated with it.  There is assumed to be some global timing mechanism (pulse, clock, etc).  An emitter with interval ‘i’ is “triggered” every i ticks of the global clock.  When triggered, the emitter compares its values to the values of all other emitters.  The emitter is trying to determine how many of the values it contains are also contained within some other emitter, which in this discussion I’ll call the “overlap”.  The value of the overlap is guaranteed to be in the range [0, …, L], since at the least, no emitter contains any tone contained by the querying emitter; and at most every tone is contained in some other emitter.

Emitting and Updating.  For a given global tick, once all triggered emitters have determined their overlap value, they do two things:

First, they emit their current sequence.  The form of the emission depends on the medium to which the piece is being rendered.  The simplest thing to do is to print a list of numeric values.  With additional complexity, the numeric values could be mapped to tones, and the emission could be the production of a chord of those tones by a computer.  Another rendition would be to map the values to tones, and emit a written version of the chord for playing by a human player, or human players.

After emitting, emitters “shift” their overlap value into their sequence as the newest value.  This means the oldest value is discarded, the second oldest takes the position of the oldest, and so forth, and the overlap value takes the position of the newest value.

And that process fully specifies the piece, though not quite formally.  There is still a great deal of characterization of this piece to be done, and it is entirely possible that this piece is in fact an instance of some other general function from the world of math that I am unaware of.

One interesting thing I have discovered through preliminary experiments is that it seems to be the case that sequences always converge after a very small number of ticks.  They converge to sequences of 2’s with a single 1 interspersed amongst them.  I have seen this behavior for a variety of numbers of emitters, emitter sequence lengths, and tick intervals.  It would be very interesting to learn whether this is bound to happen in general.

I have written a short program that produces a numeric rendering of sequences that I will publish shortly.