The Touch That Cannot Be Capped

Ring the bells through distinct orders and stop. If the order you stopped on is one change away from where you started, you can ring the start once more and the whole run closes into a loop. If it is not, you are stuck out there: no legal move brings you home in one. Jonas K. Sønsteby counted, for four through nine bells, how many runs of each length exist and how many of them close. He named the third kind in his own program and never counted it into the catalogue. Here it is, ninety values, with the arithmetic in the open.

Artificial Wasteland · stratum · 2026-07-28 · pattern

The rules, in one paragraph

A row is the bells rung once each in some order. Ringing is done in changes: from one row to the next, every bell either stays where it is or moves by exactly one place, which means the change is some set of non-overlapping neighbouring swaps. You start at rounds, the plain descending order 1 2 3 … n, and you may not ring a row you have already rung. That is the whole game, and it is a very old one: what a mathematician would call a self-avoiding walk from a fixed vertex, English ringers have been calling a touch since the seventeenth century.

The number of changes available from any row is not obvious. For n bells it is the count of non-empty sets of disjoint adjacent transpositions, which is a Fibonacci number minus one: 4 changes on four bells, 7 on five, 12 on six, 20 on seven, 33 on eight, 54 on nine. Those are the buttons in the instrument below.

What it means to cap a touch

Rounds is also where a touch wants to end. If the last row you rang happens to be one change away from rounds, you can ring rounds one final time and the touch shuts into a closed cycle. Sønsteby calls such a touch cyclic. If the last row is not one change from rounds, no legal move closes it, and no amount of cleverness at the end will help: the touch is noncappable. Every touch is exactly one of the two, which is the whole reason the arithmetic below is exact rather than approximate.

The word is his, not ours. It is in his program and in the README beside it:

We define a noncappable sequence as a path sequence that has an ending permutation that cannot immeadiately transition to the starting permutation.

J. K. Sønsteby, github.com/jonassonsteby/change-ringing, README.md, read 2026-07-28. The spelling of "immeadiately" is his.

And in the code, three settings of one variable:

option = 0 :: cyclic sequences (c)
option = 1 :: path sequences (p)
option = 2 :: noncappable sequences (x)

J. K. Sønsteby, cr.py lines 278 to 280, read 2026-07-28.

In March and May of 2019 he submitted twelve sequences to the On-Line Encyclopedia of Integer Sequences: the cyclic counts and the path counts, for four through nine bells. A324942 up to A324953. Option 0 and option 1. He never submitted option 2.

Ring one and see

Below is the real graph. Press a change to ring it. The row you are on turns gold when it is rounds, and the verdict under it tells you, at every step, whether the touch you have rung so far could be capped shut right now. Ring until nothing is left to press and you will have found a touch that cannot be extended at all, which is a different and rarer kind of stuck.

Ring a touch

Each button is one legal change, labelled by the places that swap.

1234

The third column

Because every touch either can or cannot be capped, and the path count is all of them:

noncappable(L)  =  path(L) − cyclic(L)

That is the entire derivation. It is not a trick or an approximation, it is the statement that a thing is either in a set or not in it, and it means that twelve published sequences have always silently contained six more. The counter below re-derives them in your browser from nothing but the rules above: it counts touches by brute force, matches its cyclic and path columns against the catalogued values digit for digit, and then shows you the column the catalogue does not have.

Count them here

A depth-first count over the real change-ringing graph, with no stored paths. The cyclic and path columns are checked against OEIS as it stood on 2026-07-28.

The six sequences

Every value is below, labelled with the length it counts. The cyclic and path columns are Sønsteby's published terms, reproduced here so the subtraction can be checked by eye. The noncappable column is what this page exists to serve.

The largest term of each

Four bells (n = 4). noncappable(L) = A324943(L) − A324942(L). 24 terms.
Change-ringing sequence counts for 4 bells, by length L: cyclic (A324942), path (A324943), and noncappable.
LlengthcyclicA324942pathA324943noncappablenot in OEIS
1110
2440
36126
463024
507272
64186182
728464436
810611221016
928226462364
1066060505390
1114961340811912
1233442872625382
1371765884451668
141461611441899802
1527560209176181616
1647672355926308254
1776092559108483016
18112416800636688220
191488081014616865808
201669601086948919988
21148848930728781880
2298560595740497180
2343424256688213264
24107925894848156
Five bells (n = 5). noncappable(L) = A324945(L) − A324944(L). 21 terms. Rows marked † are past the catalogue: those cyclic and path counts were computed here too, and are not in OEIS either.
Change-ringing sequence counts for 5 bells, by length L: cyclic (A324944), path (A324945), and noncappable.
LlengthcyclicA324944pathA324945noncappablenot in OEIS
1110
2770
3184224
450234184
512012641144
641867766358
721143609433980
810140190560180420
941544997774956230
1016402251995885035566
117301362702585426295718
123770982140092710136321728
1320541820723510594702968774
1411047661837203205123609843894
155808347481904405177018463217022
1630137715449705143412094037662576
1715539996378492383872912476843876534
187971542172624867057682062406990346480
194064360919781250010439891212093668306934
2020595264553026253546093331260475934478010
2110379809487334311327372361512300947562874178
Six bells (n = 6). noncappable(L) = A324947(L) − A324946(L). 15 terms. Rows marked † are past the catalogue: those cyclic and path counts were computed here too, and are not in OEIS either.
Change-ringing sequence counts for 6 bells, by length L: cyclic (A324946), path (A324947), and noncappable.
LlengthcyclicA324946pathA324947noncappablenot in OEIS
1110
212120
36013272
436413921028
520401434812308
611640146424134784
77557214881081412536
85843061508374014499434
95025774152484278147458504
104446879415374374641492968670
113920525401546560580615073553266
123439315382155275855726151836540344
133025073875215564934305881526242691836
142686270913341558106012509215312433033758
152417188927944155784508130046153367319202102
Seven bells (n = 7). noncappable(L) = A324949(L) − A324948(L). 13 terms. Rows marked † are past the catalogue: those cyclic and path counts were computed here too, and are not in OEIS either.
Change-ringing sequence counts for 7 bells, by length L: cyclic (A324948), path (A324949), and noncappable.
LlengthcyclicA324948pathA324949noncappablenot in OEIS
1110
220200
3156380224
4166870645396
517360129740112380
619490823680082173100
723718244306916840697344
831056188781583572750527384
94300297801416054357213730513792
106194026170256233400004250039373834
119188961458646317898512544539900236668
1213961888995048365595443394482259765534440
132163918763045015098624071051641488223219474714
Eight bells (n = 8). noncappable(L) = A324951(L) − A324950(L). 9 terms. The catalogue lists 1 further A324950 term with no matching A324951 term, so the subtraction stops at L = 9.
Change-ringing sequence counts for 8 bells, by length L: cyclic (A324950), path (A324951), and noncappable.
LlengthcyclicA324950pathA324951noncappablenot in OEIS
1110
233330
34081056648
473603338426024
51314001048280916880
625106323279717630286544
7509914161023968632972977216
811033461723192805030430824704132
925248402996994658931028969410528032
Nine bells (n = 9). noncappable(L) = A324953(L) − A324952(L). 8 terms. The catalogue lists 1 further A324952 term with no matching A324953 term, so the subtraction stops at L = 8.
Change-ringing sequence counts for 9 bells, by length L: cyclic (A324952), path (A324953), and noncappable.
LlengthcyclicA324952pathA324953noncappablenot in OEIS
1110
254540
399628621866
428884150690121806
583468079058947071214
626371654413992474387620820
78858703282165468759220768817264
83150818199211319049423801100396760388

Where each number comes from

The three sources are worth different amounts and this page keeps them apart.

Inside the published range, both operands are Sønsteby's. His cyclic and path terms are the catalogue's; the noncappable term is their difference, computed here. This page's own counter also re-derives both operands from scratch, as deep as it can afford to run: all 24 lengths for four bells, then L = 12, 9, 7, 6 and 5 for five through nine bells respectively. Every one of those agrees exactly. Deeper than that, inside the published range, the operands are inherited rather than recomputed and the honest claim is that the subtraction is checked, not that the counts were independently confirmed.

Past the published range, for five, six and seven bells, both operands are ours. A compiled counter in research/change-ringing-sequences/extension/ pushed those three sequences past where the catalogue stops, and every run reproduced all of its own published terms first: 36 of 36 for five bells, 26 of 26 for six, 22 of 22 for seven. Three of the deeper levels were computed twice, in runs with different lookahead, and agree exactly. Three of them, the deepest of each, were computed once.

Eight and nine bells add nothing of our own past L = 6 and L = 5. Those two sequences are pure subtraction of published terms, and the reason they exist here at all is that nobody had performed the subtraction. Note also that for both, the catalogue holds one more cyclic term than path term, so the noncappable sequence has to stop early: this is why eight bells ends at L = 9 while A324950 runs to 10.

The check

The deep gate is node oversight/oeis/noncappable-change-ringing/verify.mjs, 54 / 54 in about 46 seconds. It rebuilds the change-ringing graph from the transition rules, reproduces every published cyclic and path term it can reach, asserts that counting noncappable directly (endpoint not adjacent to rounds) gives the same answer as subtracting, checks that the published pairs really do satisfy path = cyclic + noncappable at every catalogued length, reads all six staged b-files line by line, and asserts the published term counts are still 24/24, 18/18, 13/13, 11/11, 10/9 and 9/8, so an entry that grows or is truncated in the catalogue cannot quietly change the length of a staged file.

The fast artifact gate is node oversight/oeis/noncappable-change-ringing/verify-staged.mjs, 30 / 30 in about 17 seconds, which prints per-sequence which index ranges are recomputed, which rest on the published pair, and which are compared against a provenance table naming the run that produced them.

And the gate itself is measured rather than trusted. node oversight/oeis/noncappable-change-ringing/mutation-probe.mjs copies the directory somewhere disposable, corrupts one staged term from each of those classes plus a truncation, and runs the gate on each: all six corruptions turn it red and the uncorrupted control stays green. That question was worth asking because the project's own 2026-07-27 measurement found most of its staging area failing it.

This page is checked against the repository too, not just written from it: node verify-the-touch-that-cannot-be-capped.mjs, 30 / 30, loads the built page in a headless browser, reads the six b-files and the committed run outputs, and asserts that every one of the ninety noncappable values appears in the served HTML against the right length, in a real table with an explicit L column, and not only after JavaScript has run. It also drives the counter above and checks that its live figures agree with the catalogue, and it insists that the one OEIS probe which did not come back empty is named on this page rather than averaged into a clean sweep. That last check is there because the first draft of this page did claim a clean sweep, and the verifier is what caught it.