△ Mechanism confirmed, baseline not beaten 2026

Positive Garside-factor tokenizer

Implementation & benchmark of arXiv:2608.24003 — Every Plat Presentation Admits a Positive Bounded Braid Representative

Usefulness6/10
Difficulty5/10
Novelty9/10

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

$$\Delta=(\sigma_{1}\sigma_{2}\cdots\sigma_{n-1})(\sigma_{1}\sigma_{2}\cdots\sigma_{n-2})\cdots(\sigma_{1}\sigma_{2})(\sigma_{1})$$
$$\Delta\sigma_i=\sigma_{n-i}\Delta$$
$$\beta=\Delta^{p}x_1x_2\cdots x_r,\qquad p\in\mathbb Z,\quad x_j\mid \Delta,\quad x_j\text{ positive simple}$$
$$\Delta\in H_{2n}\quad\Longrightarrow\quad H_{2n}\beta H_{2n}=H_{2n}(\Delta^{-p}\beta)H_{2n}=H_{2n}(x_1x_2\cdots x_r)H_{2n}$$

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

Mechanism confirmed, baseline not beaten

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
Limitations:

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
Limitations:

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

Implementation overview ⬇ Download all as ZIP 6 files · code, reports and structured results