Positive Garside-factor tokenizer
Implementation & benchmark of arXiv:2608.24003 — Every Plat Presentation Admits a Positive Bounded Braid Representative
Source paper: Every Plat Presentation Admits a Positive Bounded Braid Representative arXiv:2608.24003 ⓘ · analyzed Aug 29, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Replace raw braid-generator sequences by sequences of positive simple Garside factors obtained from the left-greedy normal form. Because powers of \(\Delta\) lie in the Hilden subgroup, they can be removed while preserving the relevant double-coset presentation, reducing non-uniqueness and often shortening the sequence. Feed the resulting factor tokens to a Transformer or sequence classifier, and train it to be invariant to inserted removable \(\Delta\)-powers.
Formulas
Mathematical statement
For the braid group \(B_n=\langle \sigma_1,\ldots,\sigma_{n-1}\rangle\), the paper defines the Garside element \(\Delta=(\sigma_1\cdots\sigma_{n-1})(\sigma_1\cdots\sigma_{n-2})\cdots(\sigma_1\sigma_2)(\sigma_1)\), satisfying \(\Delta\sigma_i=\sigma_{n-i}\Delta\). A Garside left-greedy normal form writes every braid as \(\beta=\Delta^p x_1x_2\cdots x_r\), where \(p\in\mathbb Z\), each \(x_j\) is a positive simple braid, meaning a positive divisor of \(\Delta\), and the factors are chosen greedily so that each prefix is maximal in the divisibility order. The Garside length is \(r\). For the \(2n\)-strand Hilden subgroup \(H_{2n}\), the paper's key observation is \(\Delta\in H_{2n}\). Hence \(\beta\) and \(\Delta^{-p}\beta=x_1\cdots x_r\) belong to the same left Hilden coset and therefore the same double coset \(H_{2n}\beta H_{2n}\). The transferable asset is a positive, factorized representative with length controlled by the original Garside length, rather than an arbitrary word containing positive and negative generators.
Implementation notes
Integrate this at the input tokenizer for a model whose inputs are braid presentations, braid-generated symbolic trajectories, or link/plat datasets. The input is a word \(w\) over signed generators \(\sigma_i^{\pm1}\). First reduce the word in the braid group using braid relations \(\sigma_i\sigma_{i+1}\sigma_i=\sigma_{i+1}\sigma_i\sigma_{i+1}\) and commutations \(\sigma_i\sigma_j=\sigma_j\sigma_i\) for \(|i-j|>1\). Compute its Garside left-greedy normal form \(\beta=\Delta^p x_1\cdots x_r\), where each \(x_j\) is represented by the permutation of strands associated with a positive divisor of \(\Delta\). Discard the integer power \(p\), because \(\Delta\in H_{2n}\), and emit tokens \([x_1,\ldots,x_r]\); optionally retain \(p\) as a separate nuisance token for ablations. Pseudocode: normal_form = garside_normal_form(word); p, factors = normal_form.infimum, normal_form.simple_factors; tokens = [factor_id(x) for x in factors]; return tokens. For batching, pad factor sequences and use a learned embedding for each simple factor, or serialize each factor as its permutation or inversion-vector representation. During training, create equivalent views by multiplying the original braid on the left or right by random powers \(\Delta^k\), normalize both, and apply a consistency loss between their model representations. The mathematics determines the factorization and valid removal of \(\Delta^p\); empirically estimate compression ratio \(|w|/r\), collision rates between known equivalent presentations, and whether retaining or dropping \(p\) affects the task. The first cheap experiment is a small Transformer on a synthetic dataset of 4- or 6-strand braids labeled by a computable invariant or generated link type. Compare raw signed-generator tokenization against Garside-factor tokens at equal parameter count. Success means lower validation error under random presentation rewrites, shorter effective sequence length, and improved accuracy at fixed attention FLOPs.
Verification
Stage 1 · Toy mechanism gate: Passed ✓
Stage 2 · Mechanism transferred to benchmark: Confirmed ✓
Stage 2 · Practical benchmark result: No measurable effect
Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works
Stage 1 — Mechanism check agent confidence 7/10
Built a readable B4/B3 positive-factor tokenizer MVP with permutation-indexed simple braids, greedy factor weighting, Delta stripping, identity checks, and a controlled centroid classifier comparison. The math sanity checks passed: Delta has the longest-strand permutation, satisfies Delta sigma_i = sigma_{n-i} Delta, normalizes to one factor, and the B3 relation 121 -> Delta is recovered. Literal left insertion of Delta powers was removed with 100% factor-sequence invariance and reduced the presented 27.04 generator tokens to 6.32 factor tokens on average (4.70x ratio); however, factor-token classification accuracy was 0.503 versus raw 0.493, effectively no meaningful ML win in this toy setup.
- Agent confidence
- 7/10
- Baseline
- raw signed-generator histogram: accuracy 0.4933; mean presented length 27.04 generators
- Idea
- positive factor tokens with literal left Delta stripping: accuracy 0.5033; mean Delta-free factor length 6.32; generator/factor ratio 4.70; Delta-removal invariance 1.0000
Limitations: This is a small exact permutation-backed positive-braid MVP, not a production arbitrary signed-word Garside normal-form implementation. It tests literal left Delta^k augmentation rather than arbitrary braid-relation rewrites or right multiplication, uses a nearest-centroid histogram classifier rather than a Transformer, and does not model a real link/plat task or measure attention FLOPs/runtime.
How to run: python3 garside_mvp.py
Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.24003)
No significant difference vs. the tuned baseline (+0.7%, p=0.8516, wins 2 / 8 paired seeds).
- Benchmark
- Braid_garside_classification
- Model
- mlp_tiny
- Paired seeds
- 8
- Baseline mean
- 0.5016
- Idea mean
- 0.5053
- Effect (Δ)
- 0.0038 (+0.7%; negative = idea better)
- Wins
- 2 / 8 paired seeds
- p-value
- 0.8516 (permutation test, 20 000 shuffles)
- Smallest detectable effect
- ±8.9%
- Mechanism
- Confirmed ✓
- Practical effect
- No effect
- Baseline tuning
- swept over 3 configs
The custom benchmark uses a small B4 positive-word task and permutation-backed factorization rather than a production arbitrary signed-word Garside normal-form implementation. It evaluates histogram features with an MLP, not a Transformer or attention-FLOP/runtime tradeoff, and tests literal left Delta-prefix augmentation rather than arbitrary braid rewrites or right multiplication.
How to run: python3 run_bench.py
Verdict computed by deterministic test code from paired-seed statistics — not by the language model.
Stage 2 — Benchmark latest Failed ✗
Agent confidence: 9/10
Built a local custom braid-presentation classification track and matched raw-generator versus positive Garside-factor systems using the same MLP, training loop, epochs, batch size, and shared learning-rate sweep. The trained factor model showed exact Delta-prefix prediction invariance and a 3.49x generator-to-factor compression ratio, confirming the mechanism quantitatively, but its test error was slightly worse than baseline and not significant (paired delta +0.00375, permutation p=0.85155).
- Baseline
- test err mean 0.50156, std 0.02225; best lr=0.001; sweep means lr=0.001: 0.50812, lr=0.003: 0.51937, lr=0.01: 0.51312
- Idea
- test err mean 0.50531, std 0.04101; best lr=0.003; paired delta +0.00375; idea wins 2/8; permutation p=0.85155; trained prediction agreement under inserted Delta prefix=1.0; observed generator/factor ratio=3.4895
Benchmark result
No significant difference vs. the tuned baseline (+0.7%, p=0.8516, wins 2 / 8 paired seeds).
- Benchmark
- Braid_garside_classification
- Model
- mlp_tiny
- Paired seeds
- 8
- Baseline mean
- 0.5016
- Idea mean
- 0.5053
- Effect (Δ)
- 0.0038 (+0.7%; negative = idea better)
- Wins
- 2 / 8 paired seeds
- p-value
- 0.8516 (permutation test, 20 000 shuffles)
- Smallest detectable effect
- ±8.9%
- Mechanism
- Confirmed ✓
- Practical effect
- No effect
- Baseline tuning
- swept over 3 configs
The custom benchmark uses a small B4 positive-word task and permutation-backed factorization rather than a production arbitrary signed-word Garside normal-form implementation. It evaluates histogram features with an MLP, not a Transformer or attention-FLOP/runtime tradeoff, and tests literal left Delta-prefix augmentation rather than arbitrary braid rewrites or right multiplication.
How to run: python3 run_bench.py
Artifacts
- bench_report.json 2.4 KB View Raw
- garside_mvp.py 5.1 KB View Raw
- garside_track.py 1.8 KB View Raw
- report.md 1.6 KB View
- report_bench_2026-09-03T022121.md 4.4 KB View
- run_bench.py 3.5 KB View Raw