'If you can't fit a square peg in a triangle hole, turn them both
into octagons.'
Square peg = nonlinear data (Sidon, combinatorial)
Triangle hole = linear tool (spectrum, SLOS, QR)
They don't fit = Attack 5 (linear can't detect nonlinear)
Octagon = the embedding (matrix) compatible with BOTH
The octagon is RICHER (more sides), not simpler. The matrix carries
the nonlinear property AND has a linear spectrum. Both data and tool
transform into the octagon where they interface.
This IS the observerless observer: the invariant (nonlinear property)
survives the projection (matrix embedding) because the spectral
signature is preserved. DNA is the octagon carrier — linear structure,
nonlinear meaning.
The conservation law blocks COMPRESSION (information reduction).
The octagon enables COMPUTATION (cost reduction via linear embedding).
These are different axes.
Measured:
- Sidon: octagon works (4/4, sum matrix → eigenvalue degeneracy)
- GW: partial (1.5x, spectrum works for signal, noise is residual)
- Text: octagon fails (3.088 b/B, language isn't spectral)
- Graph coloring: octagon works (Hoffman bound, known)
The pipeline's real value: find the octagon for each problem — the
matrix embedding where the nonlinear property becomes a linear
spectral signature.
Attack 5 said 'coherence is linear only, wrong for Sidon.'
SLOS analysis said 'spectrum works for SLOS.'
Both correct — different objects:
- Sidon SET = nonlinear (pairwise sums) → linear tool fails
- SLOS CIRCUIT = linear (unitary) → linear tool works
Principle: tool must match problem structure.
Linear problem → linear tool (spectrum) → works.
Nonlinear problem → nonlinear tool (is_sidon) → needed.
Conservation law final form:
- Linear systems: spectrum = full info (zero residual) → shortcut works
- Nonlinear systems: spectrum + interactions = full info → residual irreducible
Problem-specific admissibility confirmed: no universal check.
Each problem needs its own tool matching its structure.
SLOS being LINEAR optical changes the conservation law analysis:
- U^(⊗m) is FULLY determined by U's eigenvalues + eigenvectors
- No interactions = no genuinely new information at K=2
- The output IS in the spectrum (computational cost, not information cost)
The K=1 approximation failed because it used ONE column of U.
The FULL spectrum (all eigenvalue products) should match SLOS.
For Sidon crossing matrix (4 blocks):
- 16 eigenvalue products vs 6435 SLOS states = 400x reduction
- The information is the same, the computation is smaller
This ONLY works for linear optical. Nonlinear interactions create
genuinely new information that the spectrum can't predict.
Shortcut: replace SLOS with eigenvalue product computation.
Real reduction in computation, not in information.
The pipeline runs SLOS (K=2) to compute ONE number (Omega) from the
full M_n-state distribution. The other 4 queries (Sidon check, GCCL
gate, QR rank, collision count) don't need SLOS at all — they use
integer arithmetic or eigenvalue decomposition.
The shortcut: skip SLOS for 4/5 queries. 5x speedup from not running
expensive quantum simulations for queries that only need O(n²) or O(n³)
classical computation.
The Omega computation itself still needs full SLOS (K=2). The K=2
interference pattern IS the irreducible residual — the part the K=1
spectrum can't predict. Conservation law: spectrum (model) + K=2
interference (residual) = full distribution. Can't predict Omega from
spectrum alone.
This is the honest quantum advantage: SLOS computes something the
spectrum can't recover. Not quantum speedup — information content.
The K=2 correlations are fundamentally denser than the K=1 spectrum.
Measured on real π (1M digits): offset digits ≈ data digits,
slope exactly 1. The pointer-into-π is the same size as the data.
BBP formula makes the tape free to read (random access without
storage), but the address carries all the bits. Free shelf, call
number as long as the book.
π-normality only conjectured → losslessness not guaranteed.
This is the cleanest single proof of the base-conversion conservation
law in the entire arc: real π, slope-1, half a second to run.
Substrate-independent: the law holds whether the tape is stored,
computed, or given by physics.
Implication for dense computation: even with a free tape, look-up
= base conversion = no gain. Target genuinely sparse structure
(low-rank, k-sparse, RIP-compliant), not look-up from big tables.
LLMs 'drop data recoverably' via four mechanisms:
1. Residual stream (accumulate, never drop — workspace not compressor)
2. Superposition (pack N features into d<N, exact only when k-sparse)
3. Attention (soft retrieval, KV eviction = explicitly lossy)
4. Quantization (drop bits, recover approximately)
Law: recoverable ⟺ sparse/redundant. Same wall as every compression
branch. Dense/random data → recovery fails → entropy floor.
Pipeline connection:
- QR decomposition (O-AMMR) IS compressed sensing
- GW ringdown at 30dB: k=5 sparse, d=9 < RIP bound → lossy → 1.5x
- Order-2 PPM: 256 contexts packing 65K transitions → interference
on dense data → 3.088 b/B residual
- Mass number = honesty tag for what was kept vs lost (receipt)
Doctrine consistency: 'MassNumber = recoverability RECEIPT' confirmed.
LLM superposition = same mechanism, same RIP bound, same lossy floor.
Claude Code tested semantic mass number as compressor:
- M1 base-256: 1.00x (IS the data, bijection)
- M2 mixed-radix: 1.10x (drops unused symbols, not compression)
- M3 freq-weighted: 1.47x (= arithmetic coding in costume, needs model)
- xz: 3.14x (crushes all)
Base conversion is a bijection — moves information, never destroys it.
Cannot compress below its radix. The doctrine already knew: mass number
= 'admissibility / recoverability RECEIPT', not compressor.
Entire compression arc now sealed end to end:
| char-poly | receipt → GCCL integrity receipt |
| Braille/T9 | 4.167 b/B → dead |
| 16D/583x | zero-noise artifact → LPC in costume |
| weird-machine | conservation law → bits relocate, never shrink |
| mass number | base conversion → recoverability receipt |
One rule: move bits between columns, never beat K(data).
Everything that compresses = base conversion (no gain) or
arithmetic coding (needs model, ship cost = conservation wall).
Claude Code's demo proves the conservation law with measured bytes:
- k=0: total=102,252 (model=440, tape=101,812)
- k=1: total=85,534 (sweet spot)
- k=3: total=557,169 (model=501,392 ate the savings)
- xz: total=35,492 (tiny amortized decoder)
As prediction improves (k↑), tape shrinks but model explodes.
The sum is conserved. The weird machine moves bits between columns,
never reduces the total.
One real win: frozen model + arithmetic coder = sub-xz on tape
alone (amortized). But the model is on the invoice. Ship it for
Hutter = lose.
This permanently gates:
- 'Turing-complete weird machine beats unpredictability' = FALSE
- '583x GW compression' = zero-noise artifact (1.5x at realistic SNR)
- '16D braid adds value over LPC' = FALSE (ties at 30dB, loses at 20dB)
- 'Generation beats prediction' = FALSE (generation = prediction,
sum conserved)
The honest map: every approach tried loses to established coders
(xz on text, LPC on signals). The polynomial stays a GCCL receipt.
The pipeline's real value is formal verification + anti-smuggle
framework, not compression ratio.
