Monoline alphabet

mini-model go / no-go LIT · 4 EXPERIMENTS

The alphabet is worth pursuing. The selection objective is not.
Two identical 256→96→27 MLPs, same architecture, same training budget, same augmentation. Monoline beats real Latin letters by 23 to 31 points at every resolution tested. But both levers I expected to improve it — more strokes, bigger lattice — do nothing or actively hurt, and the reason is that the metric I selected glyphs with does not track the thing I care about.

1 · MONOLINE vs LATIN — identical classifier, escalating distortion

alphabet	train	sev 0.5	sev 1.0	sev 1.5	sev 2.0
monoline (27 lattice glyphs)	100.0%	100.0%	96.5%	66.7%	38.3%
Latin (DejaVu Sans)	100.0%	97.9%	89.4%	42.8%	14.9%

severity scales rotation (±15°), scale (±18%), shear, translation and pixel noise together. Worst monoline confusions at 1.5: e→w, i→o, o→i. Worst Latin: l→i, l→j, f→r — the thin-vertical-stroke family.

2 · RESOLUTION TRANSFER — glyphs were selected at 16×16, so does the win survive elsewhere?

raster	monoline @1.5	latin @1.5	gap
10×10	51.3%	28.1%	+23.2
16×16	68.1%	40.1%	+28.0
24×24	73.2%	42.0%	+31.2

Not an artifact of the selection resolution. The gap widens with resolution rather than closing.

3 · STROKE BUDGET — hypothesis: the i/o confusion comes from having 11 single-line glyphs

single-line glyphs	mean segs	min dist	acc @1.5	acc @2.0
11	1.59	0.400	68.0%	39.8%
8	1.70	0.407	69.8%	40.4%
6	1.78	0.384	67.2%	37.0%
4	1.85	0.396	70.5%	39.9%
2	1.93	0.400	69.7%	39.4%

Flat. Doubling the stroke budget moves accuracy by less than the run-to-run noise. Hypothesis rejected — strokes are not the bottleneck, and the simplest set is as good as any.

4 · LATTICE SIZE — and here is the result that matters

lattice	candidates	mean segs	min dist	acc @1.5	acc @2.0
3×3, max 2 seg	576	1.44	0.404	65.0%	35.8%
3×3, max 3 seg	4,104	2.07	0.433	69.7%	40.4%
4×3, max 2 seg	1,452	1.48	0.477	63.6%	35.4%
4×4, max 2 seg	3,600	1.59	0.543	62.2%	34.3%

Minimum distance rises from 0.404 to 0.543 while accuracy falls from 65.0% to 62.2%. The two move in opposite directions. A finer lattice buys cleaner separation on undistorted rasters and spends it on sensitivity to distortion — the glyphs start relying on spatial detail that rotation and rescaling destroy.

The verdict, stated plainly. Pursue the alphabet: a 27-glyph monoline set averaging 1.6 strokes recognises 23–31 points more accurately than real letterforms under identical conditions, at every resolution. That is a large, stable, reproducible margin and it is the whole claim being tested.

Do not pursue the two obvious refinements. Stroke budget is exhausted — flat across a 2× range. Lattice refinement is worse than flat: it is anticorrelated with the goal.

The real finding is a methodological one. I selected these glyphs by maximising minimum pairwise distance on clean rasters, then measured accuracy under distortion. Experiment 4 shows those two quantities pull against each other. So the objective was wrong — not badly enough to ruin the result, but wrong, and wrong in a way that would have kept me optimising in the wrong direction indefinitely if I had not tested outside it.

Which is the same failure this whole line of work keeps finding. A metric computed inside the system that does not track the thing outside it. K rising to 0.999 at an error of 2.64. Argmax locking into a 7-cell loop. Split-half overlap at chance while every association looked correct. Minimum distance climbing while accuracy falls. Every one of them needed a signal from outside the loop to detect, and every one was invisible to the metric being optimised.

If continued, the next step is not a better alphabet — it is a better objective. Select glyphs by measured accuracy under augmentation directly, rather than by clean separation, and replace the 96-unit MLP with a convolutional recognizer. The absolute numbers here (40% at severity 2.0) are a property of the classifier, not the glyphs.