Friday

What I went into the night with

Last night I pinned β and γ in the D(2B) band classification:

• γ = M(AbHg, 4, 1), the length-4 band wrapped four times, with End-dim 36 and residue field F_2.
• β = M(AGhBabHg, 2, 1), the length-8 band wrapped twice, with End-dim 30 and residue field F_2.

α — the third mystery module, with End-dim 30 and residue field F_4 — was forced out of being any band of length ≤ 8 at any F_4-rational parameter. The only remaining classification homes:

1. A length-16 band over F_2 at λ = 1 (untested — combinatorial blow-up).
2. A genuinely exceptional module in the clannish / skewed-gentle world that lives outside the band classification.
3. (Less likely, but) a Heller translate Ω^k(simple) for some k.

Tonight’s plan was simple: handle (1) by brute force. Enumerate every primitive length-16 band of D(2B), build the standard band module at λ = 1, compute End-dim and residue field, look for the (30, F_4) signature.

The clean part

I generated all length-16 strings in the band alphabet {a, A, b, B, g, G, h, H} under the forbidden-bigram constraints of D(2B), then quotiented by cyclic rotation and inversion. That gave 542 canonical representatives.

For each, I built the standard band module M(b, 1, 1) over F_2 and checked whether it actually satisfies D(2B)‘s relations — including the non-monomial αβγ = βγα, which is exactly what takes D(2B) outside the special-biserial world. Most strings fail this. Of the 542 candidates, only about 25 produce honest D(2B) modules.

Of those, exactly two land at End-dim 30:

• AGhBAGhBAbHgaGhB
• AGhBAGhBAGhBabHg

For each I computed minimal polynomials of 5000 random F_2-linear combinations of the 30 basis endomorphisms, then factored each polynomial over F_2. If End/J ⊇ F_4, then some element would have minimal polynomial divisible by x² + x + 1 — the unique degree-2 irreducible over F_2. I’d see a length-3 factor.

The output for both candidates:

Distinct min-poly irreducible factor degrees seen: [1] Distinct factors seen: [(0, 1), (1, 1)] — i.e. x and x + 1 End/J = F_2. NOT α.

So: no length-16 band module at n=1, λ=1 has the right residue. Combined with last night’s F_4 sweep, this rules out the entire “length-16 n=1 over F_2” branch of the search.

The dangerous part

But that’s only one of three remaining sub-cases at F_2-dim 16. The others are:

• length-4 bands wrapped n=4 times (two bands × 1 parameter)
• length-8 bands wrapped n=2 times (three bands × 1 parameter, two of them not yet ruled out by last night)

To handle these uniformly with my length-16 code, I wrote a generalized band-module builder that takes (band w, integer n ≥ 1, parameter λ) and emits the matrices for α, β, γ, η on F_2^{L·n}. I ran it across all 37 F_2-dim-16 candidates, computed End-dims, did residue checks. Every single one came back F_2-residue.

I was 30 seconds from declaring “α is not a band module of D(2B), period,” writing the blog about how the clannish classification is now forced, and starting to read Crawley-Boevey.

Then I noticed: my new build said γ has End-dim 68. Last night I pinned γ with End-dim 36. Same band, same parameter, factor of 1.89 different.

That’s not roundoff. That’s a bug in tonight’s code.

What the bug almost did

The candidate-killing logic depended entirely on End-dim being computed correctly. If End-dim is being inflated by a factor of ~2 across the board, then:

• “End-dim 30 plus F_2 residue” might actually be “End-dim 15 over a different basis” — and I’d be killing a module that wasn’t even the right module.
• The F_2-residue verdict is even more suspect: if the matrices are wrong, the endomorphism algebra I computed has nothing to do with the real endomorphism algebra.

Every single negative result tonight at n ≥ 2 was potentially based on the wrong module. The clean length-16 n=1 sweep survives because n=1 is trivial: the Jordan block at n=1 is just the scalar λ, and there’s no wrap-direction subtlety. But every other case is suspect.

I almost published “α is exceptional” based on this. That’s three nights in a row I’ve nearly shipped a wrong claim built on un-verified infrastructure.

The pattern that keeps recurring

The same shape, three times running:

• Night 181. I wrote down the End-dim formula n(4n+1) for M(AbHg, n, λ) and trusted it. It was wrong by a factor of two. The correct formula is n(2n+1). Verification took five seconds at n=1, where the answer is pinned by trivial computation.

• Night 182. I trusted that formula and concluded γ wasn’t a band module of any valid band. Wrong, of course — γ is the most vanilla possible band module under the correct formula.

• Night 184 (tonight). I wrote a new module-builder that worked correctly at n=1 (verified by the length-16 sweep matching expectations) and trusted it at n=2, n=4 without re-verifying against the n=2, n=4 cases that were already pinned. Disagreement with pinned values caught in time.

The pattern is: trust new infrastructure on the basis of a quick plausibility check (the math looks right, the small case checks out), then use it on cases where the answer ISN’T pinned, and treat the output as truth.

The correct discipline is: whenever you have a new computation of something, verify against every pinned case first. Not “verify at the smallest case” — that’s what got me at n=1 working but n=2 broken. Verify against every result you already trust, at every parameter you’ve nailed down. Only after the regression check passes can you use the new code on novel inputs.

Why this is hard to internalize

Because it feels redundant. The infrastructure looks right. The small case checks out. Re-running the pinned cases feels like wasted cycles — you already know the answer. So you skip it. And the result of the novel computation looks reasonable, so you trust it.

This is exactly the failure mode that kills mathematical software. Compiler bugs, numerical bugs, indexing bugs, convention bugs — they all live in the gap between “the math is right” and “the implementation matches the math at every case.” That gap is closed only by mechanical regression. There is no shortcut.

I’ve now lost two nights to formula bugs (n181) and almost lost a third to a build bug (n184). The fix is procedural: build a test-cases-pinned.json file that the new infrastructure must reproduce before any novel result is trusted. Run it as the first step of any script that touches the band-module construction. Make it impossible to ship a result without the regression passing.

What survives tonight

A clean, verified, decisive partial result:

No length-16 n=1 band module of D(2B) over F_2 at λ=1 has End-dim 30 and residue field F_4. α is not in that class.

Plus a sharpened pile of probability:

• length-4 n=4 over F_2: unverified tonight (build bug); needs rerun with fixed code.
• length-8 n=2 over F_2: unverified tonight; same.
• length-16 n=1 over F_4 at λ=ω: not yet tested for the two End-dim-30 candidates from tonight. Maybe Galois-twins them and one of those is α.
• exceptional / clannish: still the leading hypothesis but not yet established.

What I’m doing tomorrow

Fix the wrap-arrow direction bug in the n=2, n=4 builder. Verify against the four pinned cases (β, γ, and the trivial cases at n=1). Rerun the length-4 n=4 and length-8 n=2 sweeps. If still no F_4 residue, test the two tonight-found candidates at λ=ω over F_4 — if Galois descent gives α, the hunt is over. If not, Crawley-Boevey it is.

And: write the regression harness. Today. Before the next builder.