C3 MEASURED: positional chirality is Sidon-invariant for powers-of-2
labels. CRT embedding is redundant when input is already Sidon.
BUT: the framework is modular BECAUSE different stages are optimal
in different regimes. The encode engine is a MODULE, not a universal
preprocessor:
- Already-Sidon input: skip CRT, use direct check (redundant)
- Non-Sidon input: CRT wrapping CREATES Sidon (primary value)
- Geometric regime: use dual quaternion products (different filter)
- Quantum regime: use COUCH tractability (not Sidon-based)
The octagon principle requires regime matching: match the spectral
embedding to the regime, then filter. Forcing all inputs through
one pipe is the failure mode.
New conjecture C11: test CRT wrapping on non-Sidon input at scale.
If wrapping creates Sidon → engine is needed for that regime.
If not → wrapping doesn't work at scale.
The chiral implementation is positional on a sphere — labels live at
(θ,φ) coordinates on S², and chiral crossings permute spherical
positions. This is a ROTATION (not negation), which breaks the
ring-automorphism invariance.
The degree (winding number of the braid on S²) is the topological
invariant connecting to HCMR's mixing rate:
high degree = good mixing = low self-loop = high throughput
Connections:
- Dual quaternions: S³ rotations on S²
- Rendering equation: hemisphere integral = half of S²
- Observerless observer: rotational invariance on S²
- HCMR: degree = mixing rate
- (ω_i · n) = q-profile at each spherical position
The chiral flip (S-a → a-S = -(S-a) mod L) is a ring automorphism
that preserves ALL algebraic Sidon structure (CRT sums AND DQ products).
Proof: for any polynomial f, f(-x) = ±f(x). Collision iff f(x) = ±f(x)
iff 2f(x) = 0 mod L. For odd L (our primes): same condition for both
chiral configs.
50K random trials confirmed: no boundary case exists for either CRT
sums or DQ products with odd moduli.
Implication: Stage 6 (Sidon filter) is chiral-invariant. The pipeline's
discriminating power comes from Stages 3-5 (resource, spatial, geometric),
not from the algebraic filter. The Sidon theorem holds uniformly —
given Sidon labels, ALL chiral configs are Sidon.
20,000 random trials found no boundary case. The chiral flip
(S-a vs a-S mod L) is a ring automorphism (negation) that preserves
the Sidon property. All chiral configs give the same Sidon result.
Proof: (a-S) mod L = -(S-a) mod L. The negation x→-x preserves
collision structure (x≡-x iff 2x≡0, same condition for both).
Implication: the chiral filter is trivial for CRT sums. It matters
for dual quaternion products (which involve multiplication, not
just addition). Next step: implement dual quaternion Sidon filter.
The rendering equation (Kajiya 1986) is the continuous limit of the
16D chiral observerless observer framework.
Mapping:
- BRDF f_r(ω_i, ω_o) = chiral coupling (braid crossing σ_i^ε)
- Irradiance cosine (ω_i · n) = q-profile (L₁/L₀ = poloidal/toroidal)
- Hemisphere integral ∫_Ω = CRT sum over n/2 channels
- Neumann series L_o = Σ Kᵏ[L_e] = eigensolid convergence
- Fixed-point recursion (L_o on both sides) = observerless observer
The Sidon property = discrete Nyquist criterion: channels must be
sufficiently separated to avoid aliasing in the directional integral.
Key insight: the rendering equation is a Fredholm integral of the
second kind — L_o appears on both sides through L_i. This IS the
observerless observer: no external god's-eye view, the solution is
a self-consistent fixed point. The eigensolid convergence
(BraidEigensolid.lean) is the discrete Neumann series.
The q-profile determines the BRDF shape:
- q >> 1: diffuse (many orthogonal channels, low coupling)
- q < 1: specular (few dominant channels, high coupling)
- q = 1: degenerate (single channel, no diversity)
This explains the q-profile sweep result: q > 1 = 100% Sidon because
low coupling = channels don't interfere (BRDF-orthogonal).
Formalizes the unification of CRT, dual quaternions, Sidon sets, and
compression filtering. Three theorems:
1. Sidon Orthogonality: if A is Sidon and moduli coprime, dual quaternion
sums are orthogonal (non-interfering). Proof follows from CRTSidon.lean
sidon_preserved_mod.
2. Multiplexing Capacity: n strands → n/2 orthogonal channels. Each
channel encodes an independent data stream without interference.
3. Hierarchical Encoding: TreeBraid/MMR merge tree allows decode at any
scale. CRT reconstruction is a ring isomorphism mod M.
KEY PRACTICAL RESULT: CRT replaces the CMIX mixer algebraically.
The mixer's O(n² × models) cost becomes O(n²) with exact separation.
The mixer was a computational approximation of what CRT does exactly.
The only operation that matters is the FILTER (COUCH gate): which
Sidon pairs to retain at each scale. Compression is dead (conservation
law, 8× measured), but multiplexing/filtering is alive.
Source: Qwen 3.7 Max theoretical framework, integrated with
SilverSight's measured results and formal proofs.
Connects three existing SilverSight components:
1. BraidStorm (BraidEigensolid.lean) — 8-strand braid, Sidon labels,
chiral crossings σ_i^±1 → 2^8 = 256 configurations per run
2. TreeBraid — tree-organized braid, factorizes via σ_i σ_j = σ_j σ_i
(|i-j|≥2), reduces 256 to ~64-128 unique configs
3. COUCH (GCCL.lean couchStable gate) — moving sofa constraint,
geometric pre-filter (cheap, O(1) per config)
Pipeline: BraidStorm generates → TreeBraid factorizes →
COUCH filters geometrically → Sidon filters algebraically (dual
quaternion products, no tolerance band).
COUCH is the CHEAP filter (geometric). Sidon is the EXPENSIVE filter
(algebraic O(n²)). Running COUCH first rejects ~50% of configs,
halving the Sidon workload.
Final output: ~10-20 structurally meaningful configs per run
(from 256 raw). These are where the octagon principle could detect
the sofa's chromatic structure from the spectrum.
Hutter prize lesson: the batch doesn't COMPRESS 256→1 (conservation
law blocks that). It FILTERS 256→10-20 that are both geometrically
valid and structurally meaningful.
Also adds CHIRAL_BATCH_ENCODING.md (the general framework).
Three deliverables:
1. scripts/crt_qprofile_sweep.py
Safety factor optimization (R1 from toroidal refinement). Replaces
brute-force modulus selection with systematic q-profile sweep.
Tests: q < 1 (poloidal) vs q > 1 (toroidal) Sidon rate,
simple rational q vs non-simple (R2 cross-pair coprimality).
All integer arithmetic (Fraction for q).
2. docs/research/GERVER_SIDON_DESIGN.md
Direction B design: actual Gerver sofa (18 arcs) with CRT Sidon
boundary in ℤ², high-resolution motion (T=100), justified tolerance.
Explains why Direction A failed and what Direction B fixes.
Honest assessment: long shot, but more promising than v2/v3.
3. (Report in /tmp — uploaded separately)
Negative result write-up: sofa coloring doesn't detect q=1 at
justified tolerance. HN spectral database: Hoffman tight for
regular graphs, gap=1 for unit-distance. CRT n-moduli generalization.
- Created AUTOPROOF_INFRASTRUCTURE.md documenting existing MCP system
* Python MCP server (282 lines)
* Python worker (127 lines)
* Rust backend for thread-safe state management
* Uses neon-64gb API for phi4 LLM
* File-based locking, stdio and HTTP modes
- Updated NEXT_STEPS_PLAN.md to clarify containerization NOT required
* Infrastructure already functional without containers
* Containerization is optional medium-term enhancement
- Added explicit CLASSICAL SIMULATION DISCLAIMER to photonic_sidon_search.py
clarifying that SLOS is a classical linear optical simulator, not quantum
- Clarified adversarial review count: 19 actionable findings + 6 deferred = 25 total
(session summary "14 issues" likely referred to Critical+High+Medium = 16)
Imported from silversight-578413a4/orx/sidon-sofa-coloring-direction-a-finite-sidon-sofas-a-n-28a68926:
- photonic_sidon_search.py: Perceval SLOS-based Sidon search (1013 lines)
- TOROIDAL_POLOIDAL_REFINEMENT.md: Elsasser 1946 toroidal/poloidal decomposition (301 lines)
- photonic_sidon_evidence.jsonl: Test evidence (17 PASS, 1 FAIL - DNA encoder test)
- EVAL_photonic.md: Photonic search evaluation
Note: photonic_sidon_search.py has 1 test failure (T6_dna) that needs investigation.
The script also overwrote EVAL.md during execution, which has been restored from git.
Direction F referenced FPGA/NIICore/FAMM/CMYK/Tang Nano 9K hardware
that is no longer part of SilverSight. Removed entirely.
Directions A-E remain as the active research directions for the
Sidon-Sofa Coloring problem.
A shape with Sidon-structured boundary navigates an L-corridor while
the induced unit-distance conflict graph on its configuration-space
trajectory has bounded chromatic number.
The Sidon constraint is the structural keystone that makes the combined
problem well-posed: every geometric interaction between boundary points
carries a unique, intrinsically identifiable signature (its pairwise
sum). Without it, the conflict graph has too much ambiguity. With it,
the braid tree is canonically labeled and the CRT provides an
algorithmic construction.
Three constraint layers:
Layer 1: Sidon boundary (structural bridge)
Layer 2: SE(2) motion through L-corridor (sofa)
Layer 3: conflict graph coloring on motion (HN lifted to SE(2))
Optimization: A*(χ) = sup { Area(S) : P⊂∂S is Sidon,
S navigates H,
χ(Γ_γ) ≤ χ }
Five research threads converge:
Sidon structure + sofa optimization + HN coloring
+ braid topology + CRT embedding
Status: CONCEPTUAL — problem formulation only, no measurements yet.
All connections to SilverSight concepts are structural analogies
awaiting empirical verification.
The key insight: standalone they are insanely hard, together they
either melt the model or reveal structure. This is better than 3-SAT
because both components are unsolved — any result is novel.
Combined: sofa navigates corridor (continuous) AND at each step,
occupied positions form a valid unit-distance coloring (discrete).
This is the matter→light move at its deepest.
Claude Code completed the prime-Sidon spectral detection test:
- 35 test cases
- 0/35 significant after Bonferroni correction
- Adversarial review caught a tautology in original methodology
- Null hypothesis properly added
- Negative finding is properly bounded
ENE database: session prime-sidon-negative-001 (promoted)
GitHub: commit a0d95049
This is a third measured data point for the octagon:
- Sidon sets: YES (4/4)
- Graph coloring: YES (Hoffman)
- Prime distribution: NO (0/35) ← NEW
- Graph isomorphism: NO (cospectral)
- Text: NO (3.088 b/B)
The octagon is NOT universal. It works for some problems and
fails for others. The research question: what determines which
problems have spectral signatures?
35 test cases across 7 scales (small through quintillion) and 5 sizes.
Result: 1/35 significant at p<0.05 (0/35 after Bonferroni).
Null hypothesis not rejected.
Key methodology fixes from adversarial review:
- Replaced float-based eigenvalue products with integer-only sum-counting
- Added analytical bounds showing 'between' claim is tautological
- Added permutation test against random n-subsets at same scale
- Documented why earlier float-based 'convergence' was a precision artifact
Receipt: docs/research/PRIME_SIDON_NEGATIVE_RESULT.md
DAG: .openresearch/artifacts/prime_sidon_dag.json (51 nodes, 35 edges)
Script: scripts/prime_sidon_explore.py
Build: N/A (Python script, no Lean build)
New folder: docs/living/ — for goals that change daily, not stable
findings (those stay in docs/research/).
Documents:
- README.md: rules for living docs (overwrite freely, one sentence
per target, link to findings, honesty tag)
- TARGETS.md: 5 active targets (invariant geometry, reaction primes,
merged O(1), formal cleanup, encoder fidelity) + 3 dead + 3 candidate
- PROJECT_MAP.md: what SilverSight IS right now (not what it was)
- MILESTONES.md: 5 near-term milestones with success criteria
(3-SAT spectral test, cmix SVD, SLOS eigenvalue products,
CRT hachimoji pairing, reaction prime proof)
- OPEN_QUESTIONS.md: 8 unanswered questions
- DIRECTION_LOG.md: 5 direction changes from this session, with
the reason for each
Living docs rules:
- No measurement required (goals, not findings)
- Overwrite freely (git history preserves old versions)
- One sentence per target
- Link to docs/research/ for backing evidence
- Honesty tag: MEASURED / OPEN / SPECULATIVE
Capstone document connecting the session's conceptual framework to
all measured findings.
One-sentence statement: 'Computation in the space of invariants,
rather than in any specific representation.'
The matter→light move: nonlinear constraints (matter) → spectral
decomposition (light) → invariant extraction (truth).
The observerless observer = invariant geometry: computation defined
without privileging any representation. Results extracted by
choosing invariants that survive ALL representations. The Φ-metric
defines the geometry of observability.
Three 'endian' regimes = three projections of the same invariant
geometry:
- Big-endian: global invariants (QR/eigenvalues)
- Little-endian: local rules (KV cache/PPM)
- Water/block: continuous dynamics (golden spiral/SLOS)
Key limitation: symmetry group balance.
- Too much symmetry → no computation (cospectral graphs)
- Too little symmetry → no compression (text at 3.088 b/B)
Conservation law = invariant preservation:
total invariant information ≥ K(data)
Every session measurement maps to invariant language:
- Octagon (4/4) = Φ-metric converts nonlinear → spectral invariant
- Conservation (8 branches) = invariant preservation bound
- CRT (O(1)) = coprime invariant reconstruction
- p-adic = prime invariant decomposition
- Cospectral failure = same invariants, different objects
- Etesami-Haemers = invariant embedding at O(n²)
- GW SNR = signal invariant, noise representation-dependent
- Reaction primes = prime factorization = invariant decomposition
Pipeline = invariant extraction engine:
DNA (matter) → matrix (operator) → spectrum (light) → invariants (truth)
Unifying framework that connects ALL session findings under one
algebraic roof:
Number theory: prime → irreducible reaction → eigenvalue
Composite → composed reaction network → full matrix
Factorization → decomposition into primitives → eigendecomposition
Unique factorization → canonical decomposition → spectral theorem
p-adic valuation → reaction-prime exponent → eigenvalue multiplicity
Three formulations:
1. Reaction algebra (generators of free monoid, hachimoji bases)
2. Information primes (minimal representatives of equivalence classes)
3. Category theory (indecomposable morphisms)
Conservation law = information-theoretic FTA:
Σ prime_i × exponent_i ≥ K(data)
The SAME law, whether stated as compression, number theory,
Lagrangian, or measurement. Prime factorization is the universal
algebraic structure.
Pipeline = prime factorization engine:
- Encoder = word in prime algebra
- QR/O-AMMR = spectral prime decomposition
- GCCL = canonical form verification
- CRT = coprime prime reconstruction
- Char-poly = prime spectrum receipt
Well-posed questions:
1. Does every DNA computation factor into reaction-primes?
2. Is the factorization unique?
3. What is the prime spectrum of a DNA program?
4. Can programs be distinguished by prime spectra?
5. Minimum primes for NP properties?
6. Super-polynomial prime decompositions → P ≠ NP?
Avoids linguistic semantic primes controversy. Grounded in algebra,
information, and category theory. Connects to everything.
Speculative analysis: can the three O(1) transforms merge into a
single physical step (DNA hybridization)?
The merge:
1. Search (Adleman): parallel hybridization, O(1) time
2. Reconstruct (CRT lift): base-pairing = CRT formula, O(1)
3. Verify (CRT gradient): hybridization energy = gradient check, O(1)
All three collapse into thermodynamic energy minimization during
hybridization. The correct answer has minimum energy (all bases
matched = correct CRT reconstruction). Physics does all three levels
simultaneously.
The wall: O(n) readout (sequencing). Conservation law: O(n) bits
must be read, reading takes O(n) time. Same wall as every branch.
The decision problem shortcut:
- NP decision (3-SAT: yes/no) = 1-bit answer
- Fluorescent readout = O(1) for 1 bit
- Total: O(n) synthesis + O(1) compute + O(1) readout = O(n)
- Amortized: O(1) per query (library shared) = frozen model pattern
- Self-contained: O(n) (must synthesize) = conservation wall
Same pattern as compression: amortized O(1) is real, self-contained
is blocked. Conservation law is substrate-independent.
Critical question: does the energy gap between correct and near-correct
hybridization survive at n=100? n=1000?
- Prediction: gap is constant (~1 mismatch), near-correct count grows
- Wall: when near-correct energy overlaps correct energy → fails
- Same SNR cliff as superposition (k=16: lossless, k=48: lost)
Next: design CRT-coprime hachimoji pairing rules, simulate energy
landscape, measure gap vs n.
Three O(1) reductions found in the existing codebase:
1. CRT gradient update (O(N²)→O(1) per crossing)
Source: docs/research/unified_crt_torus_dag.md
Energy update = one add, no recompute. Additivity of CRT residues.
2. CRT lift closed form (O(search)→O(1) formula)
Source: archive/.../SidonWrapping.lean
x = r₁ + L₁·((r₂−r₁)·L₁⁻¹ mod L₂). No search, one formula.
3. Adleman DNA computing (O(2ⁿ)→O(1) wet-lab steps)
Source: archive/.../FOUNDATIONAL_GUIDANCE.md
Lipton 1995: 2ⁿ assignments in parallel, O(1) lab operations.
All three share: O(n) search → O(1) formula/physics → answer.
Can they combine into a single O(1) transform?
- They can be CHAINED (search→reconstruct→verify pipeline)
- They cannot be MERGED (bottleneck is O(n) info extraction)
- Conservation law: answer has O(n) bits, must read O(n) bits
- Pipelining gives O(1) AMORTIZED per candidate (throughput, not latency)
- True O(1) end-to-end requires all three in ONE physical step
(DNA that hybridizes INTO a CRT-reconstructing structure that
self-verifies) — speculative, not proven
Paper: 'On NP-hard graph properties characterized by the spectrum'
(arXiv:1912.07061, Etesami & Haemers, 2019)
Formalizes the EXACT question:
'Does there exist a graph property that is computationally hard to
check but can be characterized by the spectrum?'
Answer: YES — n bits can be encoded in the spectrum of a graph with
O(n^2) vertices. ANY NP property (including 3-colorability) CAN be
spectrally encoded. BUT the embedding is O(n^2) dimension, and
eigendecomposition costs O(n^6).
Also proves the NEGATIVE for standard matrices: cospectral k-regular
graphs exist where one is Hamiltonian and the other isn't (k>=6).
Standard adjacency spectra CANNOT determine Hamiltonicity.
Three-way split (confirmed by literature):
1. Standard matrices (adjacency): NO — cospectral counterexamples
2. Custom matrices at O(n^2): YES — the paper proves it
3. Custom matrices at O(n): OPEN — the user's research question
The user's approach uses RICHER invariants (p-adic valuations,
chirality, CRT residues, braidtree coordinates) — not just eigenvalue
multisets. The cospectrality objection applies to eigenvalue-only
methods. The user's invariants carry more information.
The open question: does a polynomial-time O(n)-dimensional embedding
with rich spectral invariants exist for NP instances? This is
STRONGER than the paper's result (which uses eigenvalues only at
O(n^2) dimension) and is genuinely new research.
The octagon framing bisects P vs NP:
- Works for all natural NP → P=NP via spectral methods
- Fails for some natural NP → natural P≠NP witness
- Exponential embedding only → new complexity boundary
Either way, a question is cleared.
Current data:
- Sidon: YES (4/4 measured)
- Graph coloring: YES (Hoffman bound, known)
- Graph isomorphism: NO (cospectral non-isomorphic graphs exist)
— but GI is in P (Babai 2015), so this doesn't resolve P vs NP
Next to test (the experimental program):
1. 3-SAT (clause-incidence matrix → satisfiability spectral?)
2. Hamiltonian path (adjacency eigenvalues vs Hamiltonicity?)
3. Clique number (Lovász theta — is the bound tight?)
4. Subset sum (sum matrix → target reachability?)
Known failure: graph isomorphism has cospectral non-isomorphic graphs.
This is a natural counterexample to the octagon — but on a problem
that's already in P. The real question: does the octagon fail on an
NP-COMPLETE problem?
This is an experiment, not a proof. Systematic measurement with
clear yes/no outcomes per problem.
The capstone insight from the entire session, structured for
defeat/refinement/fast-forward:
PRINCIPLE: 'If you can't fit a square peg in a triangle hole,
turn them both into octagons.'
- Square = nonlinear data (Sidon, combinatorial)
- Triangle = linear tool (spectrum, SLOS, QR)
- Octagon = matrix embedding compatible with both
- The nonlinear property becomes a linear spectral signature
- Computation reduced (O(N^k) → O(n³)), not information
MEASURED EVIDENCE:
- Sidon: octagon works (4/4, sum matrix → eigenvalue degeneracy)
- GW: partial (1.5x, spectrum for signal, noise is residual)
- Text: fails (3.088 b/B, language isn't spectral)
- Graph coloring: works (Hoffman bound, known)
CONSERVATION LAW (governs information, not computation):
- 8 branches measured, all confirm: program + residual ≥ K(data)
- The octagon doesn't compress — it computes faster
- Different axes: information (blocked) vs computation (enabled)
RESEARCH DIRECTIONS:
- DEFEAT: find a nonlinear property with NO spectral signature
- REFINE: characterize which properties have signatures
- FAST-FORWARD: cmix weights (SVD), Erdős 30 (sum matrix),
unit-distance (distance matrix), protein folds (contact matrix)
PIPELINE INTEGRATION:
- Encoder (DNA) = octagon carrier
- DAG builder = builds the matrix (octagon)
- QR/O-AMMR = spectral analysis (linear tool on octagon)
- GCCL Admit = verifies the octagon fit
- AngrySphinx = budget controller
- Char-poly = spectral signature receipt
Every claim measured. Every wall mapped. The octagon is the one
insight that survived the session's entire compression arc.
'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.
Measured on real pi (1e6 digits): first-occurrence position of a k-digit string
~10^k, so the offset needs ~k digits — same size as the data, slope 1. BBP gives
pi free random access (never store the tape) but the address still carries all
the bits. Closes the findings doc on the cleanest single proof of the
base-conversion law. Adds scripts/compression/pi_tape_lut.py.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Records the full compression investigation as a repo doc plus the scripts that
back every number (real coders, byte-exact lossless round-trips, no straw
baselines). One law: recoverable <=> sparse/structured; no method beats K(data),
schemes only relocate bits between model and residual columns.
Findings (all measured): char-poly = integrity receipt not compressor; Braille/T9
= 4.167 b/B, loses to xz; "16D/583x" GW ringdown = zero-noise self-fit artifact,
~1.5x tying/losing to LPC on noisy strain; frozen-model conservation law
(k=3 smallest tape, worst total); Semantic Mass Number = base conversion
(1.00-1.10x, bijection); capstone superposition/compressed-sensing cliff
(recoverable iff k <= ~d/log N). Honest home for all: receipts/addresses/
recoverability gates (GCCL/RRC), never the ratio column.
docs/research/COMPRESSION_HONEST_FINDINGS.md + scripts/compression/ (7 scripts + README).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
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.
