△ Mechanism confirmed, baseline not beaten 2026

Markov-coded synchronization-robust latent streams

Implementation & benchmark of arXiv:2607.03989 — The Insertion List-Decoding Capacity and an Improved Bound on the Deletion List-Decoding Capacity

Usefulness6/10
Difficulty5/10
Novelty7/10

Source paper: The Insertion List-Decoding Capacity and an Improved Bound on the Deletion List-Decoding Capacity arXiv:2607.03989 ⓘ · analyzed Aug 29, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace an independently generated discrete latent sequence or redundancy stream with a symmetric two-state Markov source whose transition probability is tuned or learned. Train the downstream transformer to reconstruct the semantic target after random insertions, while using the paper's insertion-capacity expression to select the latent rate and redundancy budget. The representation should preserve information under timing drift, repeated tokens, and inserted distractors better than iid token augmentation.

Formulas

$$R_{\mathrm{ins}}(\delta)=(1+\delta)\left(1-h\left(\frac{\delta}{1+\delta}\right)\right),\qquad h(p)=-p\log_2p-(1-p)\log_2(1-p).$$
$$P(z_1=0)=P(z_1=1)=\frac12,\qquad P(z_t=z_{t-1})=1-q,\qquad P(z_t\neq z_{t-1})=q.$$$$
$$\mathcal C\text{ is }(\delta,L)\text{-list-decodable}\iff \forall y\in\{0,1\}^{(1+\delta)n}:\ \left|\{c\in\mathcal C:y\text{ is a supersequence of }c\}\right|\leq L.$$$$
$$R_{\mathrm{NN}}=\frac{\log_2|\mathcal Z|}{m}\leq(1-\varepsilon)(1+\delta)\left[1-h\left(\frac{\delta}{1+\delta}\right)\right].$$

Mathematical statement

For insertion fraction $\delta\in[0,1]$, a binary code $\mathcal C\subseteq\{0,1\}^n$ is $(\delta,L)$-list-decodable from insertions if every received string $y\in\{0,1\}^{(1+\delta)n}$ has at most $L$ codewords $c\in\mathcal C$ for which $y$ is a supersequence of $c$. The paper states that the insertion list-decoding capacity is $R_{\mathrm{ins}}(\delta)=(1+\delta)[1-h(\delta/(1+\delta))]$, where $R=(\log_2|\mathcal C|)/n$ is code rate and $h(p)=-p\log_2p-(1-p)\log_2(1-p)$ is binary entropy. Codes sampled from a symmetric two-state Markov chain achieve this rate with high probability and polynomial list size. In the neural adaptation, let $z_{1:m}\in\{0,1\}^m$ be a latent code, let $q$ be its transition probability, and use the stationary Markov source $P(z_1=0)=P(z_1=1)=1/2$, $P(z_t\neq z_{t-1})=q$. The neural representation rate is $R_{\mathrm{NN}}=\log_2|\mathcal Z|/m$; choose $R_{\mathrm{NN}}\leq(1-\varepsilon)R_{\mathrm{ins}}(\delta)$ with safety margin $\varepsilon$. The extracted theorem does not specify an optimal $q$, so $q$ must be selected empirically.

Implementation notes

Integrate this at the discrete latent or tokenizer output of a small sequence autoencoder, or use it for a redundant control stream prepended to transformer inputs. Start with a binary latent stream of length $m$ per example. Map each bit to a learned embedding and feed the embeddings, together with the semantic input, to a transformer encoder-decoder. Generate the stream using the symmetric Markov prior: sample the first bit uniformly, then sample each next bit equal to the previous bit with probability $1-q$ and flipped with probability $q$. For differentiable training, use straight-through Bernoulli samples, Gumbel-Softmax, or continuous bit logits, and add the Markov negative-log-prior to the objective: $-\log P(z_{1:m})=-\log P(z_1)-\sum_{t=2}^m\log P(z_t\mid z_{t-1})$. During training, insert $\lfloor\delta m\rfloor$ random latent tokens at uniformly sampled positions; train the decoder to recover the semantic target. Choose stream length and codebook size so that $R_{\mathrm{NN}}\leq(1-\varepsilon)R_{\mathrm{ins}}(\delta)$ for $\varepsilon\in[0.1,0.3]$. The capacity expression is computed exactly; $q$, the margin, and the corruption distribution are empirical choices. First test on binary sequence classification or byte-level ListOps with a 6-layer transformer, comparing iid binary latents against Markov latents at equal latent length and FLOPs. Evaluate clean accuracy, accuracy after 10%, 25%, and 50% insertions, and examples needed to reach a fixed corrupted-data accuracy. Success is a robustness gain at fixed clean accuracy with less than 10% training overhead.

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 6/10

Built a reproducible iid-versus-Markov latent-stream benchmark with exact insertion-capacity/rate computation, sampled subsequence list-collision checks, and a small GRU classifier trained on inserted streams. At delta=0.25, n=12, M=8, the rate 0.25 satisfies the 10% safety-margin bound 0.3128; q=0.25 improved accuracy at 25% insertions (0.950 vs 0.936) and 50% insertions (0.826 vs 0.714), despite slightly more sampled list collisions. The signal is promising but q-dependent: q=0.4 improved 25% robustness but was worse than iid at 50%, so this is not evidence of a universal win.

Agent confidence
6/10
Baseline
iid q=0.5: clean 1.000, 25% insertion 0.936, 50% insertion 0.714; sampled mean list size 1.084, collision fraction 0.083
Idea
Markov q=0.25: clean 1.000, 25% insertion 0.950, 50% insertion 0.826; sampled mean list size 1.151, collision fraction 0.148. Capacity(delta=.25)=0.3476, safe rate at epsilon=.1=0.3128, tested rate=.25.

Limitations: Only a tiny synthetic binary identification task was tested, with n=12, M=8, two random repetitions per configuration, and a GRU rather than a transformer. The experiment used random insertions only, did not learn q, did not add the Markov negative-log-prior objective, and did not establish asymptotic list-decodability or FLOP/sample-efficiency gains. CUDA cuDNN allocation failed and the training automatically fell back to CPU.

How to run: python3 experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.03989)

No significant difference vs. the tuned baseline (+0.7%, p=0.4024, wins 3 / 8 paired seeds).

Benchmark
Sequence modeling
Model
transformer_tiny
Paired seeds
8
Baseline mean
1.2005
Idea mean
1.2093
Effect (Δ)
0.0088 (+0.7%; negative = idea better)
Wins
3 / 8 paired seeds
p-value
0.4024 (permutation test, 20 000 shuffles)
Smallest detectable effect
±2.0%
Mechanism
Confirmed ✓
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

Only the built-in sequence forecast track was tested; no learned q, Markov prior loss, transformer decoder, explicit semantic latent autoencoder, or multiple insertion fractions were evaluated. The redundancy stream was supplied as an auxiliary channel and corruption was truncated back to the fixed transformer window, so this is a transfer test rather than a complete tokenizer implementation.

How to run: python3 bench_experiment.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

Implemented a structurally matched sequence-level benchmark using the fixed transformer_tiny architecture, identical forecast data, insertion corruption, training budget, and paired seeds for iid and Markov redundancy streams. The mechanism signature was quantitatively confirmed: configured q=0.25 produced observed transition rate 0.2421. However, Markov achieved test MSE 1.2093 versus iid baseline 1.2005, paired delta +0.00878, with permutation p=0.40245; this is no measurable effect and not a significant improvement.

Baseline
sequence transformer, iid stream, best lr=0.001; full 8-seed test MSE 1.200540 ± 0.095050
Capacity
R_ins(delta=0.25)=0.347590
Idea
sequence transformer, Markov q=0.25, best lr=0.001; full 8-seed test MSE 1.209323 ± 0.108909
Mechanism signature
predicted q=0.25, observed transition rate=0.242097, observed persistence=0.757903, confirmed=true
Paired delta
idea - baseline = +0.008783 MSE; 3/8 idea wins; permutation p=0.40245

Benchmark result

No significant difference vs. the tuned baseline (+0.7%, p=0.4024, wins 3 / 8 paired seeds).

Benchmark
Sequence modeling
Model
transformer_tiny
Paired seeds
8
Baseline mean
1.2005
Idea mean
1.2093
Effect (Δ)
0.0088 (+0.7%; negative = idea better)
Wins
3 / 8 paired seeds
p-value
0.4024 (permutation test, 20 000 shuffles)
Smallest detectable effect
±2.0%
Mechanism
Confirmed ✓
Practical effect
No effect
Baseline tuning
swept over 3 configs
Limitations:

Only the built-in sequence forecast track was tested; no learned q, Markov prior loss, transformer decoder, explicit semantic latent autoencoder, or multiple insertion fractions were evaluated. The redundancy stream was supplied as an auxiliary channel and corruption was truncated back to the fixed transformer window, so this is a transfer test rather than a complete tokenizer implementation.

How to run: python3 bench_experiment.py

Artifacts

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