add spec

TAG_CLASSIFY_SPEC.md

@@ -0,0 +1,171 @@
+# Tag-classify pretokenization — design spec
+
+**Principle (simdjson move):** compute a per-char **tag** stream in *one* SIMD pass, then every
+pretokenizer is a cheap consumer over that stream. Two orthogonal tag alphabets (**atoms** for
+category-based pretokenizers, **scripts** for `UnicodeScripts`) are produced by the *same* generic
+range-classify engine — only the tables differ. 0-dep at runtime (tables bake to `const`;
+`unicode_categories` is a dev-only *generator* dep, like `bitmap_gen`).
+
+```
+                       ┌── classify<Lanes, Table> ──► tag[]  (one SIMD pass, char-start aligned)
+ text (UTF-8 bytes) ───┤
+                       └── char-start bitplane      (for multibyte / char-count)
+                                     │
+   tag = ATOM (u4)                   │                    tag = SCRIPT (u8)
+     │                               │                          │
+     ├ remap(vqtbl1) → class-view ───┤                          └ FSM: split on script change
+     │                               │                              (Common/Any/Inherited transparent)
+     ├ RunSplit FSM (SIMD boundary + extract)   ← WhitespaceSplit, Whitespace, Punctuation, Digits, Bert
+     └ Cl100k/ByteLevel FSM (scalar, segmented) ← cl100k, GPT-2
+```
+
+---
+
+## 1. The atom alphabet (12 tags, fits `u4`)
+
+Derived by enumerating all 1.1M codepoints against the exact predicates in the pretokenizer code
+(`scratchpad/atomgen`). 10 base atoms + the two ASCII specials promoted (Space, Apostrophe).
+
+| # | atom | definition | example |
+|---|---|---|---|
+| 0 | `Letter` | `\p{L}` | `a 中 é` |
+| 1 | `NumWord` | `Nd ∪ Nl` (numeric **and** `\w`) | `0-9 Ⅷ ٠` |
+| 2 | `NumOther` | `No` (numeric, not `\w`) | `½ ² ¼` |
+| 3 | `Newline` | `\r \n` | |
+| 4 | `Space` | `0x20` only | ` ` |
+| 5 | `WsOther` | `\s ∖ {\r\n, 0x20}` | `\t` NBSP U+2028 |
+| 6 | `Mark` | `\p{M} ∪ {ZWJ,ZWNJ} ∪ (Other_Alphabetic∖L)` | combining marks |
+| 7 | `Connector` | `\p{Pc}` | `_ ‿` |
+| 8 | `Punct` | `(\p{P}∖Pc) ∪ ASCII-sym`, minus `0x27` | `! . , + = < $` |
+| 9 | `Apostrophe` | `0x27` only | `'` |
+| 10 | `SymOther` | non-ASCII `\p{S}` ∪ control ∪ unassigned | `× ©` U+0000 |
+| 11 | `NumericOther` | `is_numeric ∖ \p{N}` | numeric-typed non-numbers |
+
+`Cont` (continuation byte) is the 13th value or, equivalently, tag `0xFF` + `char_start=0`; it's
+transparent to every FSM. Base predicates that forced the split (proven, not guessed):
+`is_alphabetic ≠ \p{L}` (27043 cps), `is_numeric ≠ \p{N}` (478 cps → atom 11), ASCII-vs-Unicode
+symbol asymmetry (ASCII sym → 8, non-ASCII sym → 10).
+
+## 2. The generic classify engine (composable lanes)
+
+`classify` walks 16-byte chunks. Per chunk it runs **lanes**, each gated by a cheap
+`vmaxvq` range test so ASCII-only chunks skip the multibyte lanes entirely. Every lane maps its
+byte-region to a tag; the *structure* is shared across tag alphabets, only the per-lane **table**
+changes. A `Classifier` = an ordered set of lanes + their tables.
+
+| lane | byte range | mechanism | shared? |
+|---|---|---|---|
+| **ASCII** | `< 0x80` | `LUT128[byte] → tag` (nibble-shuffle / range) | structure shared; table per-alphabet |
+| **2-byte** | `C2–DF` | codepoint bitmap (`vqtbl` `LETTER2`…) *or* range | per-alphabet |
+| **CJK** | `E3–EC` | lead-byte range → tag (atoms: `Letter`; scripts: `Han`) | structure shared |
+| **3-byte-other** | `E0–E2, ED–EF` | **SIMD range-search** (Thai/Devanagari; the must-fix) | structure shared |
+| **4-byte** | `F0+` | SIMD range-search (rare) | structure shared |
+| **cont** | `80–BF` | tag = `Cont`, `char_start=0` | shared |
+
+**SIMD range-search kernel** (used by the 3-byte/4-byte lanes, and the whole script classifier):
+a sorted threshold list classifies branchlessly by *counting thresholds cleared* —
+`range_id = Σᵢ (cp ≥ tᵢ)` via broadcast `vcgeq` + accumulate, then `tag = TAG_LUT[range_id]`
+(a `vqtbl1`). No binary search, no data-dependent branches, 16 lanes at a time. This is why the
+3-byte-non-CJK marks/letters gap has **no scalar slow path**.
+
+Output: `tag[]` (one byte per input byte; continuation bytes = `Cont`) + a `char_start` bitplane.
+
+## 3. Composition: atoms and scripts are the same engine
+
+```
+AtomClassifier   = { ASCII: ATOM_ASCII_LUT, 2byte: ATOM_BITMAPS, CJK: →Letter,
+                     3byte: ATOM_GC_RANGES, 4byte: ATOM_GC_RANGES }
+ScriptClassifier = { ASCII: SCRIPT_ASCII_LUT (mostly Common/Latin), 2byte: SCRIPT_RANGES,
+                     CJK: →Han,  3byte: SCRIPT_RANGES, 4byte: SCRIPT_RANGES }
+```
+
+Same lane code, same gating, same SIMD range kernel — swap the tables. `UnicodeScripts`'
+`fixed_script` (Hira/Kata→Han, space→Any) is a post-remap, the same slot atoms use. So
+`UnicodeScripts` reuses the entire classify + FSM framework; it is *not* a second system, it's a
+second instantiation. (Script ⊥ atom at the *value* level — `'a'`/`'а'`/`'中'` are one atom, three
+scripts — so they remain separate streams; you run whichever the configured pretokenizer needs.)
+
+## 4. Pretokenizer interface
+
+```
+PreTokenizer = {
+    classifier: &Classifier,     // Atoms (almost always) or Scripts
+    remap:      Remap,           // tag → consumer class
+    fsm:        Fsm,             // class-view → spans
+}
+```
+
+- **`Remap`**: for `≤16` tags (atoms) it's a **16-byte `vqtbl1`** table — 16 chars remapped in one
+  instruction. For scripts (`>16` tags) there is no small remap; the FSM compares script-ids directly.
+- **`Fsm`** kinds (all local over the remapped tag view; the boundary stream is `tag ∈ mask`):
+  - `Split { delim_mask, behavior }` — the HF delimiter split. A char is a *match* iff `tag ∈
+    delim_mask`; matches are per-char, non-matches are runs; then `behavior ∈ {Removed, Isolated,
+    Contiguous, MergedWithPrevious, MergedWithNext}` places boundaries / drops the match segments
+    exactly as `SplitDelimiterBehavior` (normalizer.rs). Covers WhitespaceSplit (`WS`,Removed),
+    Punctuation (`Punct∪Pc∪Apostrophe`,Isolated), Digits (`numeric`,Contiguous),
+    Metaspace (`Space→▁`,MergedWithNext), CharDelimiterSplit (byte), Split-literal.
+    → SIMD class-change → movemask → `extract`; `Contiguous`/`Removed`/`Isolated` are pure boundary
+    masks (bitmask *wins* here), `MergedWith*` a one-lane shift.
+  - `ClassRuns { drop_mask, isolate_mask }` — cut at *every* class change; drop `drop_mask` runs,
+    isolate `isolate_mask` per-char. Covers Whitespace (drop `WS`, keep Word+Symbol runs) and Bert
+    (drop `WS`, isolate `Punct`). This is the case that keeps *two* run types, so it isn't a single
+    `Split`.
+  - `Cl100k` / `ByteLevel` — the 7-rule (GPT-2) **scalar** FSM (segmented `{1,3}` / ws-tail — measured
+    to beat the bitmask here). Peeks original bytes for the contraction suffix literals (ASCII).
+  - `ScriptRun` — run-split on script change, transparent set `{Common, Inherited, Any}` sticks to the
+    neighbouring run.
+
+FSMs read the **tag stream** as primary input and may peek the **original bytes** for literal matches
+that tags can't encode (cl100k contraction suffixes `'s`/`'re`, Metaspace marker, delimiter char).
+
+## 5. Remap tables (atoms → consumer class), all `[u8;16]`
+
+Atom index:  `0 Letter · 1 NumWord · 2 NumOther · 3 Newline · 4 Space · 5 WsOther · 6 Mark · 7 Connector · 8 Punct · 9 Apostrophe · 10 SymOther · 11 NumericOther`
+
+```
+                 0    1    2    3    4    5    6    7    8    9   10   11
+cl100k        [  L,   N,   N,  NL,  SP,  WS,   O,   O,   O,  AP,   O,   O ]   // AP triggers rule 1; SP is rule-4 ` ?`
+ByteLevel     [  L,   N,   N,  WS,  SP,  WS,   O,   O,   O,   O,   O,   O ]   // no \r\n split
+Whitespace    [Wrd, Wrd, Sym,  ws,  ws,  ws, Wrd, Wrd, Sym, Sym, Sym, Sym ]
+WhitespaceSpl [  ·,   ·,   ·,  WS,  WS,  WS,   ·,   ·,   ·,   ·,   ·,   · ]
+Punctuation   [  ·,   ·,   ·,   ·,   ·,   ·,   ·,   P,   P,   P,   ·,   · ]
+Digits        [  ·,   N,   N,   ·,   ·,   ·,   ·,   ·,   ·,   ·,   ·,   N ]
+Bert          [  O,   O,   O,  WS,  WS,  WS,   O,   P,   P,   P,   O,   O ]   // ws-split + isolate punct
+```
+
+## 6. Outside the tag substrate
+
+- `Split(regex)` — runtime pattern; **feature-gated**, rarely used. Escape hatch, not designed for.
+- `CharDelimiterSplit` — arbitrary single byte; a byte compare, touches no tag.
+- `FixedLength` — positional char count; rides the `char_start` bitplane only.
+- Metaspace / cl100k-apostrophe — literal-byte matches; FSM peeks original bytes (§4).
+
+## 7. Portability (SIMD and non-SIMD share one table set)
+
+Every table (`LETTER2/3`, `NUMBER2/3`, and the new `MARK2/3`/`PUNCT2/3`/`SYM2/3`/`CONNECTOR` +
+3-byte range tables) is arch-independent **data**, baked `const` by `bitmap_gen` (dev-only generator).
+Each lane has two readers producing the *identical* tag:
+
+| lane | SIMD reader (aarch64) | scalar reader (portable) |
+|---|---|---|
+| ASCII | nibble-shuffle | `LUT128[byte]` |
+| 2/3-byte bitmap | `vqtbl` gather | `(TABLE[idx] >> bit) & 1` — **this is `FastLetter/FastNumber::step`** |
+| CJK / range | branchless `Σ(cp ≥ tᵢ)` | plain range loop / binary search |
+
+So `classify_cats` = `#[cfg(aarch64)] classify_neon` else `classify_scalar`, both emitting the same
+`tag[]` (one byte-exact gate covers both). The **matchers already built are the scalar 2/3-byte
+reader**, reused as-is. Downstream is already portable: `remap` is a table index; the FSMs are scalar
+even on NEON (the shipped split *is* scalar). The only aarch64-only piece is the SIMD boundary-extract
+optimisation for `Split`/`ClassRuns`; its scalar fallback is a run-scan (the measured winner for short
+runs regardless).
+
+## 8. Speed contract
+
+- **classify** is the one hot pass; keep the ASCII/2-byte/CJK fast lanes, SIMD range for the rest.
+  No scalar slow path (range kernel is branchless SIMD).
+- **remap** is 1 `vqtbl1` / 16 chars.
+- **RunSplit** pretokenizers extract via SIMD boundary bitmask (this is where the bitmask *wins* —
+  no segmented rules).
+- **cl100k/ByteLevel** stay scalar-FSM (segmented rules; measured winner vs onig 5–45×, byte-exact).
+- byte-exactness gate: every FSM's output must equal its reference (regex / current impl) over a
+  multi-script corpus. That single assert has caught every bug in this line of work.