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.
Claude Code measured the parametric model vs LPC across SNR regimes:
- clean (0 noise): 111x (the '583x' claim lives here only)
- 60 dB: 2.3x
- 30 dB (realistic): 1.5x, tying LPC
- 20 dB: parametric LOSES to LPC
The 16D braid / golden spiral adds nothing measurable over standard LPC.
At realistic SNR, lossless compression converges to ~1.5x because the
residual IS detector noise, which is incompressible.
This permanently gates the 583x claim. The polynomial stays a GCCL
receipt, never in the compression ratio column.
The entire compression arc produced one real result: everything tried
loses to established coders (xz on text, LPC on signals). The honest
map is now documented with numbers behind every claim.
0a: static Fisher–Rao on Δ₃ proven constant-curvature 1/4, ∇R≡0 (symbolic).
0b: rossbyDriftFromChirality drift-flip metric has signature (2,1), drift
direction time-like at 3 exact rational points.
0c: drift-flipped metric is PROPER — not locally symmetric (108 nonzero
∇R components at centroid, exact), not semisymmetric, not Deszcz-
pseudosymmetric (inconsistent L ratios at two points).
0d: obstruction is carried by the drift direction.
Refutes the semi-symmetry hypothesis for the drift-FLIP geometrization at
m=4; Randers/torsion geometrizations and the m=8 Sidon-block case remain
open (Δ₇ run pending).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Loads codebook/codeword/fingerprint/equation vertices with in_cluster,
shares_fingerprint and within_cartan_floor(fisher_distance) edges into
the mathblob/concepts graph, mirroring the Research Stack
load_module_graph.py conventions (pk partition key, coalesce upserts,
RU-throttle retry). Applied 2026-07-02: 273 vertices + 339 edges ok;
250 pre-existing equation vertices refreshed in place with exact values.
Docs note the Spark-side JDBC verification of ene.rrc_predictions.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
STEP 1 — integer spiral-index packing (EXACT): pack_spiral_index/
unpack_spiral_index with corpus-wide base=2·max|c|+1 and offset-encoded
digits, recorded in the codebook JSON header; round-trip verified over
all 250 matrices. Fixes the sign bug in integration_sprint.py's integer
path (unoffset signed packing collapsed (-1,1) with (1,0) in base 2).
STEP 2 — f(n) layout (DECORATIVE): per-entry radius_sq + angle_frac,
computed in decimal arithmetic (indices reach ~1e44 >> 2^52); verified
against VERIFICATION_LOG V007 f(20121); min angular separation ≈4.64e-6
of a turn reported.
STEP 3 — Cartan Δ-floor (--cartan-floor): Δ=17/1792 exact
(CartanConnection.lean:70) as Fisher-distance resolution floor on Δ₇;
13 sub-Δ pairs merge 196 fingerprints into 187 Δ-resolution codewords
vs 9 gap-rule clusters; emitted alongside, not replacing, the 3×-median
rule. Caveat asserted in tests: the |c|/Σ|c| simplex projection is
lossy (one corpus pair at Fisher distance 0) — similarity, not identity.
STEP 4 — torus-winding saturation fix: TorusWinding gains
a_exact/b_exact (plain ℤ, no Q16.16 clamp); torus_to_spiral_index
prefers them, making the round trip lossless (regression-tested at
n=1e9). BraidEigensolid.lean needs the same widening — noted, Lean
untouched.
Also corrects charpoly_codebook.py's stale docstring counts (192/180 →
196/182, cross-checked against the exact Faddeev–LeVerrier fingerprints:
identical on all 250 matrices).
Tests: 43 passed (19 new).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Adds python/spectral_codebook_db.py: sync codebook rows into
ene.rrc_predictions on the neon-64gb Postgres (NEON_PG convention from
scripts/auto/auto_pipeline.py, default research_stack DB).
- Row shape (flat, SQL-typed, Spark-JDBC readable): equation_id,
proxy_pred = cluster codeword C0..C8, exact_pred = shape from exact
lambda under CURRENT ClassifyN.lean thresholds (1.5/4.0 Q16.16,
integer semantics mirrored), matrix_hash =
'charpoly=<c1..c8>;pos10=<base-10 positional hash>' (similarity +
injective identity keys), confidence = 1.0 unique fingerprint / 1/k
in k-way charpoly collision class; deterministic uuid5 ids so reruns
upsert idempotently.
- SAFE BY DEFAULT: dry run prints summary + sample SQL and writes
nothing; --apply required to insert (psycopg2, with --emit-sql
data/spectral_codebook_sync.sql fallback when the driver is absent).
--apply has NOT been run; live DB untouched. --verify-schema does a
read-only column check; schema verified offline against
scripts/auto/ene_schema.sql in tests (live check left to the user
per the ask-before-DB-work rule).
- spectral_codebook.py gains --sync-db (always dry-run from that entry
point). Dry-run counts: 250 rows; C0=35 C1=20 C2=13 C3=79 C4=29
C5=15 C6=22 C7=19 C8=18; Logogram=69 Signal=131 CognitiveLoad=50;
183 rows at confidence 1.0.
- docs: 'Neon data layer' section — ENE table map, stale
ene.rrc_classifications finding (120 rows with artifact spectral
radii 0.3-0.85 predating the exact-eigenvalue fix; recommend
re-classification via this codebook), empty landing tables, Spark
JDBC snippet, arxiv-pg (podman-exec only) citation layer note.
- tests: 8 new dry-run/no-network tests (23 total).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Implements the Next Steps of docs/SPECTRAL_CODEBOOK_ANALYSIS.md as
python/spectral_codebook.py (stdlib-only; NumPy optional fast path):
- Parses the 250 8x8 braid adjacency matrices from PIST/Matrices250.lean.
- Primary fingerprint: exact integer characteristic-polynomial
coefficients via Faddeev-LeVerrier in Fraction arithmetic (196 unique
over 238 distinct matrices, vs 179 unique lambda at 4dp; 6 cospectral
non-identical groups; 11 exact-duplicate matrix groups / 23 ids).
- Corrects the analysis doc: the 9 'mid band' lambda in (0.5,1) are
power-iteration non-convergence artifacts - exact rho = 1.0 for all 9
(peripheral spectra). spectral_radius is now the exact max root
modulus (numpy eigvals or Durand-Kerner on the exact char poly);
power-iteration lambda kept only for traceability.
- Gap-aware quantization: dedupe to 238 distinct matrices, boundaries at
gaps > 3x median gap, min-support guard (>=10 distinct per cluster),
sparse-tail outlier flagging above lambda ~= 7.66. Result: 9 clusters.
- Round trip encode(matrix) -> (codeword, index) -> decode -> equation_id
verified bijective over all 250 in tests/test_spectral_codebook.py.
- 278-row RRC/Q16_16Manifold corpus: 28 extra rows are repeated ids;
boundaries reproduce exactly, no new gaps or clusters.
- Emits data/spectral_codebook.json (schema spectral_codebook_v2) with
explicit collision classes; docs/SPECTRAL_CODEBOOK_GENERATOR.md notes
the hashMatrix base-5 injectivity gap and the ClassifyN threshold
(1.5/4.0 Q16.16) vs analysis-doc (0.5/1.0) mismatch.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
