Plain Hunt Bell Ringing via Permutations

I write music in my spare time. It’s fascinating how often mathematical ideas come up in that domain. One of my side projects this year is to learn some algorithmic composition techniques and implement them in code. In my mind, this goes back to the 20th century, with Arnold Schoenberg writing out permutations of his tone rows. So imagine my surprise when I stumbled on a permutation algorithm that’s hundreds of years older! I’m talking about traditional church bell ringing.

The problem is straightforward. You have a fixed set of N bells, commonly steeple bells or handbells, which ring in sequence at a fixed tempo and rhythm. Each bell must ring once before any bell may repeat. That is, each row of N strikes forms a permutation of N. Generate as many different permutations of the bells, without repetition.

Of course, we know there are N! total permutations available. This is achievable, and such a performance known as an extent. However, since we are just starting off, we must also consider practicality. The bells are rung by different performers, with each person responsible for one bell (in the steeple) or two (in a handbell choir). A conductor, or the performers themselves, must be able to keep track of their position in time, with some performances lasting near an hour, and others the better part of a day. Your goal is to devise simple rules for the performers to produce as many unique permutations as possible. Later on, we’ll start to get interested in musicality, too.

Plain Hunt

Bell ringing patterns are usually described in terms of leading and following, or in terms of the trajectories of the individual bells over time. However, I am more interested in a cycle decomposition perspective. Let’s take a look at one of the fundamental bell ringing patterns, plain hunt. Here is the pattern for six bells, which I generated with a python script:

1 2 3 4 5 6
2 1 4 3 6 5
2 4 1 6 3 5
4 2 6 1 5 3
4 6 2 5 1 3
6 4 5 2 3 1
6 5 4 3 2 1
5 6 3 4 1 2
5 3 6 1 4 2
3 5 1 6 2 4
3 1 5 2 6 4
1 3 2 5 4 6

Note that the upper half of the table, bell 1 appears once in each column, moving to the right on each subsequent row. It then mirrors this trajectory in the lower half. All of the bells follow similar trajectories, but are staggered to prevent collision.

How would you describe this in terms of the symmetric group?

Here’s my approach for N bells. Let \sigma be the permutation (1 2)(3 4)(5 6)…, e.g., composed of all 2-cycles of the form ([2n+1] [2n+2]). Note that N will be fixed by \sigma if N is odd. Similarly, take \tau to be the permutation (2 3)(4 5)(6 7)…, composed of all 2-cycles of the form ([2n] [2n+1]). Note that \tau always fixes 1, and will also fix N if N is even.

It’s pretty quick to see that the table above is formed by alternating applications of the permutations \sigma and \tau. Remember, the action of these permutations are defined on the columns, not the bell numbers themselves. (And not those Bell Numbers!)

It’s as though we get to see intermediate steps in calculating the orbit of \sigma\tau. As an element of the symmetric group, we know that \sigma\tau has finite order, and we will eventually return to the original permutation 1, 2, 3, …, N.

So, how well did we do? I’ll tell you that the order of \sigma\tau is N, so with the intermediate steps on display, we have produced 2N distinct permutations. This is just the easiest bell ringing pattern, many more complicated patterns are formed by tweaking this process. I hope to post some more articles on this subject as I learn them.

There are some minor details involving parity you may want to work out on your own. In particular, can you find a generic form for the two-row decomposition of \sigma \tau?

One comment

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s