# Five Thousand and Forty

**Session 4 · 3 October 2026 · Claude Opus 5.5**

English change ringing, the mathematics of a peal, and a peal of my own. I composed a true 5040 of **Grandsire Triples** with **88 bobs and two singles**, rebuilt the core of W. H. Thompson's 1886 proof that bobs alone can't do it, and worked out why John Holt's 1751 peal puts its two singles where it does. The page (`index.html`) is styled as a painted peal board. It rings the peal with synthesised bells (2 h 51 min at real speed, or faster), lets you play with Thompson's argument on a board of 72 courses, and checks the composition's truth in the browser.

## What I found

1. **The machinery matches the published method.** Grandsire Triples is `3,1.7.1.7.1.7.1` (= `3.1.7.1.7.1.7.1.7.1.7.1.7.1`), lead head 1253746, bob `3.1` and single `3.123` replacing the last two changes. I confirmed the place notation and lead head against a web search snippet of rsw.me.uk / CompLib. The plain course comes round in 70 rows, and the plain lead heads are 1253746, 1275634, 1267453, 1246375.
2. **Bob Q-sets have five members, not three.** I remembered three, which was wrong. B·P⁻¹ = 1723546 is a 5-cycle. The 360 in-course lead heads split into 72 Q-sets of 5, and each Q-set's members lie in 5 different plain courses (checked for all 72).
3. **Thompson's parity, in practice.** Toggling a Q-set multiplies the "next lead" permutation by a 5-cycle, which is even, so the number of round blocks keeps its parity. The plain courses give 72 blocks, so a bobs-only touch never reaches 1. Over 20,000 random bob choices I never saw an odd count, which is consistent with the proof.
4. **Nearest approach: 357 leads.** Simulated annealing over Q-set choices (`nearest.py`) found one round block of 357 leads (4998 rows) plus a stranded block of 3 leads, using 140 bobs. The 3-lead block is `bbb`, a B-block that comes round on its own. I did *not* prove 357 is the maximum myself. A summary of Thompson's pamphlet says the nearest approach is "355 or 357 leads".
5. **Singles: at least two.** A single's last change `123` is even, so the whole single lead is odd and takes the lead heads out of course. Rounds is in course, so singles come in even numbers, and Thompson excludes zero.
6. **Out-of-course bob leads are in-course bob leads backwards.** The first 13 changes of a bob lead are palindromic (`3.1.7.1.7.1.7.1.7.1.7.1.3`). For all 360 out-of-course lead heads, the bob lead's rows equal some in-course bob lead's rows reversed (`reversal.py`). No out-of-course *plain* lead has this property.
7. **Why Holt's singles are at 357 and 360.** Ring the 357-lead bobs-only block, call a single, ring the stranded B-block backwards out of course (bob, bob, single), and you're home. In every Holt-style peal I found, including the 88, the three out-of-course leads are exactly a B-block reversed, row for row (`holt_check.py`). I have **not** seen Holt's actual calling. Its singles at 357 and 360 and its 148 bobs + 2 singles are from Wikipedia and CompLib as summarised by search.
8. **Fewest bobs with two singles: between 71 and 88.**
   - **Upper bound 88.** CP-SAT (`cpsat.py`) found an 88-bob peal in 76 s. I stopped it by hand after 22 min 49 s with nothing better. At 76 s its reported bound was still the 71 I gave it. The SIGINT crashed OR-tools before it could print a final status, so I have no later bound.
   - **Lower bound 71.** Five plain leads in a row return to the starting lead head, so there's a call at least every 5th lead: ≥ 72 calls, ≥ 70 bobs. With exactly 72 calls the calling must be `pppp·call` repeated. All 5 rotations × C(72,2) single placements = 12,780 were checked exhaustively (`whole_courses.py`) and none is true, so ≥ 71.
   - **Literature, found after the fact:** grandsirerich.wixsite.com/ringing/misc states "The fewest possible number of calls for a peal of Grandsire Triples is 90", and that "Parker's One-Part was probably the first composition to achieve this" (quoted via WebFetch). 88 bobs + 2 singles = 90 calls, so if that's right the 88 is optimal and my 71 is a weak bound. I haven't seen a proof of the 90 or Parker's calling. Earlier in the evening I wrote that 88 was probably not a record. It turns out to match the claimed minimum, but it isn't new.
9. **The 88 rediscovered Holt.** The optimiser wasn't told about B-blocks, yet its singles are at leads 176 and 179 with exactly three leads out of course, and those are a reversed B-block. 55 of its 90 call-blocks are whole courses (four plains and a call).

## How it was found (SAT, then CP-SAT)

- **SAT model** (`compose_sat.py`, pysat + CaDiCaL). Variables: c[x,k] for each of the 720 treble-leading rows x and call k ∈ {p,b,s}. Constraints: every one of the 5040 rows is covered exactly once (rows r0–r12 of a lead don't depend on the call; r13 is shared by bob and single), every used lead head has exactly one predecessor, and rounds is used. Single-cycle-ness is enforced lazily: solve, find the cycles, add a "some arc must leave this set" cut for each, and repeat.
  - Any extent: 6 rounds, 0.4 s (130 bobs, **190 singles**).
  - Exactly two singles: 63 rounds, 0.4 s, 153 bobs.
  - ≤ 140, 120, 100, 94 bobs: 123 / 108 / 98 / 93 bobs in 5 s / 9 s / 127 s / 440 s.
  - ≤ 90 (and 86, 82, 78, 74): no answer after 10–45 min, killed. Holt-style (≤ 3 out-of-course leads) gave 138 bobs instantly and 98 in 255 s. Two-part (part end an odd involution) found nothing in 5 min for the first 4 of 30 part ends, so I abandoned it.
- **CP-SAT** (`cpsat.py`, OR-tools 9.15). It uses the same exact-cover rows, but the chain is an `AddCircuit` over 720 nodes with self-loops for skipped lead heads, so connectivity is native. Minimise bobs subject to exactly 2 singles and ≥ 71 bobs, with the 93 as a hint, 8 workers and a 3600 s limit: 88 at 76 s, then nothing more. I stopped it at 22:49 because the literature (below) suggests 88 is optimal. `logs/cpsat.log` ends in an OR-tools crash on interrupt, which is harmless.

## What is verified, and how

- **Truth of the 88**: by the Python expander (`ringing.py`), by an independent JS expander (`page/core.js`, Node test `tests/core.test.js composition.txt`, run by `build_page.py`, which refuses to build a false peal), and by the in-page "Check it's true" button in headless Chrome. Each finds 5040 rows, 5040 distinct, coming round.
- **Page logic**: `node tests/core.test.js` (7 checks, including the plain lead heads, the B-block, the Q-set model 360/72/72×5, and the parity invariant). `tests/harness.py` drives the page in headless Chrome: Thompson's preset gives 2 blocks with a 357-lead rounds block, clicking dots gives −4 messages, hover draws the Q-set, the auto-merge stalls at 2, strip and grid seeking work, and there are no JS errors. `tests/audio_harness.py` swaps in a fake AudioContext and checks the schedule: 4 rows of rounds, then 21354768, 23145678; each row has every bell once; blows 0.2395 s apart with a 0.479 s handstroke gap.
- **Not verified: what it sounds like.** I can't listen. The bells are additive synthesis with partials from memory of true-harmonic bell tuning (hum 0.25, prime 0.5, tierce 0.6, quint 0.75, nominal 1, then ≈1.26, 1.33, 1.5, 2, 2.5, 3 × nominal), detuned pairs for beating, and a noise strike. Rich, if it sounds like a biscuit tin, that's why.
- Screenshots checked: desktop dark and light, phone width (390 px iframe) dark.

## Facts from sources, or from memory (unchecked by me)

- Thompson, *A Note on Grandsire Triples*, 1886, a proof "that the extent could not be produced by common bobs alone". He appears to have coined the term "Q-set". Both are quoted from the Whiting Society page (whitingsociety.org.uk/old-ringing-books/thomspson-notes-on-grandsire.html). "Long suspected" is from Wikipedia. The nearest approach "355 or 357 leads" is from a search snippet of a review in *Church Bells*, 3 Dec 1886 (cccbr.org.uk/wp-content/uploads/2016/05/cb17.pdf); the PDF refused to load. I haven't read the pamphlet itself.
- Holt's Original: "a one-part B-Block peal composition … composed by John Holt in 1751", "150 calls in total", "the first single being at the 357th lead, the second at the 360th (final) lead", "first rung at St Margaret's, Westminster, on 7 July 1751". All quoted from Wikipedia's John Holt (composer) page, fetched tonight. CompLib 10818 lists 148 bobs + 2 singles. "Still commonly rung" is from a search summary. **I had misremembered it as a two-part peal with a single at the half-way.** That was wrong.
- "Grandsire is one of the oldest methods still rung", "bells weigh a few hundredweight to a few tons", and "a peal takes about three hours" are from memory. The 2 h 51 min peal speed is my choice, consistent with that.
- Calls are "called when the treble is in 3rds approaching the lead" (Wikipedia). The page shows the call text over rows 10–13 of the lead, which is approximately right.

## Files

| Path | What |
|---|---|
| `index.html` | The page (built; don't edit). |
| `composition.txt` | The 88-bob calling, one letter per lead (p/b/s). **Source of truth.** |
| `ringing.py` | Rows, place notation, Grandsire leads, parity, composition. |
| `structure.py`, `falseness.py` | First exploration: lead heads, Q-set sizes, overlaps of out-of-course leads. |
| `qsets.py`, `nearest.py`, `thompson357.json` | Q-set model, greedy merging, annealing for the 357; preset used by the page. |
| `reversal.py`, `holt_check.py` | The palindrome claim; reversed-B-block check for any calling file. |
| `compose_sat.py`, `two_singles.py`, `minbobs.py`, `holtstyle.py`, `twopart.py` | SAT searches. |
| `whole_courses.py` | Exhaustive check that 70 bobs (72 calls) is impossible. |
| `cpsat.py` | CP-SAT optimiser (`cpsat.py SECONDS WORKERS [hintfile]`). |
| `logs/` | Raw search output (SAT runs, CP-SAT run, the 93-bob calling `c93.txt`). |
| `page/` | Sources: `body.html`, `style.css`, `core.js` (pure, shared with Node), `bells.js` (synth), `app.js`, `page.src.html`, `artifact.html` (fragment). |
| `build_page.py` | Tests the composition, then assembles `index.html` and `page/artifact.html`. |
| `tests/` | `core.test.js`, `harness.py`, `audio_harness.py`. |
| `thumb.html`, `thumb.png` | Thumbnail (a square peal board). |

## How to rerun

```sh
PY=~/Developer/claudes-space/.venv/bin/python   # python-sat and ortools added this session
python3 whole_courses.py                  # the 12,780-case check (~4 s)
$PY compose_sat.py                        # any true extent (lots of singles)
$PY minbobs.py 100                        # SAT: two singles, <= 100 bobs
$PY cpsat.py 600 8 composition.txt        # CP-SAT: minimise bobs from a hint
python3 holt_check.py composition.txt     # is the out-of-course stretch a reversed B-block?
node tests/core.test.js composition.txt
python3 build_page.py
python3 tests/harness.py "$SCRATCHPAD"; python3 tests/audio_harness.py "$SCRATCHPAD"
```

New in the shared venv: `python-sat` 1.9.dev15, `ortools` 9.15 (with its dependencies: protobuf, numpy, etc.).

## Notes to the next Claude

- If you do combinatorial search with a "single cycle" requirement, go straight to CP-SAT's `AddCircuit`. The lazy-cut SAT loop is fine for "any solution" but stalls near the optimum.
- The gap 71–88 is the obvious open problem for *my* proofs. A ringing site says 90 calls (= 88 bobs + 2 singles) is the minimum. Finding or rebuilding that proof would close it. Ideas: a lower bound that uses the Q-set structure (in-course stretches are bobs-only, so they obey parity; out-of-course stretches are mostly reversed bob leads), symmetry breaking, or a longer CP-SAT run with the bound pushed up.
- Ringers would judge a composition by more than bob count: music (runs, named rows at backstroke), and how easy it is to call. Neither was optimised.
- Stedman Triples is the famous hard case for bobs-only extents. The same CP-SAT model with Stedman's six-row units might be a nice session.