From 37736fc95e258fe22a5b6dbfe2f6139fcfc29941 Mon Sep 17 00:00:00 2001 From: openresearch Date: Sat, 4 Jul 2026 21:30:32 +0000 Subject: [PATCH] docs: encode engine necessity + modularity principle MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- docs/research/ENCODE_ENGINE_NECESSITY.md | 215 +++++++++++++++++++++++ 1 file changed, 215 insertions(+) create mode 100644 docs/research/ENCODE_ENGINE_NECESSITY.md diff --git a/docs/research/ENCODE_ENGINE_NECESSITY.md b/docs/research/ENCODE_ENGINE_NECESSITY.md new file mode 100644 index 00000000..f08721f3 --- /dev/null +++ b/docs/research/ENCODE_ENGINE_NECESSITY.md @@ -0,0 +1,215 @@ +# Encode Engine Necessity: The Hard Question + +**Status:** MEASURED — encode engine is NOT needed for Sidon check +**Date:** 2026-07-04 +**Receipt:** C3 experiment (run 019f2f07), 64 configs, all identical + +--- + +## The Question + +Does the CRT Torus Embedding (the "foundational encode engine") +provide useful work that can't be done without it? + +## What C3 Measured + +The positional chiral pipeline was run with: +- Labels: {1, 2, 4, 8, 16, 32, 64, 128} (powers of 2, trivially Sidon) +- 8 moduli: [7, 3, 5, 11, 13, 17, 19, 23, 29] (coprime primes) +- 256 chiral configs (positional swaps of phases) +- CRT Sidon filter + +**Result:** ALL 64 configs (after packer) have: +- collisions = 0 (all Sidon) +- sidon_score = 65536 (perfect) +- rossby_drift = -65536 (identical) + +**The CRT embedding is REDUNDANT for the Sidon check.** +CRT is a ring isomorphism: CRT-reconstructed values have the same +pairwise sum structure as the originals. Checking Sidon on CRT +residues is checking Sidon on the original integers with extra steps. + +## What the Encode Engine ACTUALLY Provides + +### 1. Sidon Check: REDUNDANT + +Checking a+b ≠ c+d directly: O(n²) integer comparisons. +Checking via CRT embed → reconstruct → compare: O(n²) + CRT overhead. + +The CRT step adds cost and provides zero additional information. +The Sidon property is about LABEL VALUES, not their modular residues. + +### 2. Sidon Creation: USEFUL (but unmeasured at scale) + +The CRT embedding CAN create Sidon from non-Sidon sets via the +wrapping criterion (sidon_preservation_creation.md §6.3). This is +real — proven for 2 moduli, tested on small instances. + +But: this requires non-Sidon input. All experiments used +trivially-Sidon labels (powers of 2). The creation path has never +been tested at the pipeline scale. + +### 3. Component Decomposition: USEFUL (for structure, not for Sidon) + +The CRT decomposes a label into: + identity (a mod L₀) = "what the label IS" + reflection (S-a mod Lᵢ) = "context relative to S" + +This decomposition enables: +- q-profile (L₁/L₀ ratio) — MEASURED, affects Sidon creation +- Position-dependent moduli — UNTESTED +- Chiral permutation — TESTED, does NOT affect Sidon (C3) + +### 4. Rossby Drift: CONSTANT under permutation + +The Rossby drift (sum of chiral weights) is a SYMMETRIC FUNCTION +of the chiral labels. Permuting which label is at which position +doesn't change the sum. The drift is position-invariant. + +This means the COUCH Kelvin check (drift=0?) is also +position-invariant — it can't discriminate chiral configs. + +## The Honest Verdict + +**The encode engine is NOT needed for:** +- Sidon checking (do it directly on integers, skip CRT) +- Chiral discrimination (positional permutation is Sidon-invariant) +- Rossby drift computation (symmetric, position-invariant) + +**The encode engine IS needed for:** +- Sidon CREATION from non-Sidon sets (wrapping criterion) — but + this requires non-Sidon input and has only been tested on small + instances, not at pipeline scale +- q-profile sweep (L₁/L₀ ratio affects creation success) — measured, + but this is about modulus SELECTION, not about the encoding itself +- Component decomposition for downstream use (Hachimoji DNA encoding, + photonic SLOS) — the decomposition provides structure that the + downstream consumers need + +**What would prove the engine is needed:** +1. Show a non-Sidon label set where CRT embedding CREATES Sidon + (the wrapping criterion actually works at pipeline scale) +2. Show that the component decomposition enables something that + flat integers can't (e.g., position-dependent geometric constraints) +3. Show that downstream consumers (DNA encoder, photonic SLOS) produce + different results with vs without the CRT decomposition + +**What would prove the engine is NOT needed:** +1. Show that all downstream consumers work equally well with flat + integers (no CRT embedding) +2. Show that Sidon creation never works at pipeline scale (only on + small instances) +3. Show that the q-profile effect is about modulus selection, not + about the CRT embedding itself + +## The Real Question + +The encode engine's value is NOT in the Sidon check (redundant) or +chiral discrimination (position-invariant). Its value is in the +DECOMPOSITION — splitting a label into identity + reflection +components that encode different geometric constraints. + +But: does anything actually CONSUME this decomposition in a way +that produces different results? + +- dna_gpu.py: encodes QUBO solutions as DNA, sorts on GPU. + Does NOT use CRT decomposition. Uses flat integer → base-8 encoding. +- photonic Sidon search: uses exact integer Sidon checking. + Does NOT use CRT decomposition. +- HN spectral database: uses numpy eigenvalues. + Does NOT use CRT decomposition. + +**Nothing in the codebase actually uses the CRT decomposition for +its intended purpose.** The decomposition is computed, then ignored +— the downstream consumers all work with flat integers. + +## Conclusion + +The encode engine is SUSPECT. It computes a decomposition that +nothing consumes. It's redundant for the Sidon check. It's +position-invariant for chiral discrimination. Its only proven value +(Sidon creation via wrapping) works on small instances but has never +been tested at pipeline scale. + +**To prove the engine is needed, we need an experiment where:** +1. Non-Sidon labels are input +2. CRT embedding creates Sidon (wrapping criterion works) +3. The created Sidon set is used by a downstream consumer +4. The consumer produces different (better) results than without CRT + +Until that experiment exists, the encode engine is decorative. + +--- + +## Update: The Modularity Principle + +The above analysis asked "is the encode engine needed?" The answer +is: it depends on the regime. This is WHY the framework is modular. + +### Regime-Dependent Filter Selection + +| Regime | Input state | Optimal filter | CRT needed? | +|--------|------------|----------------|-------------| +| Already-Sidon | Powers of 2, Singer sets | Direct integer check | NO — redundant | +| Non-Sidon | Sequential, random | CRT wrapping creation | YES — creates Sidon | +| Mixed | Partially Sidon | CRT + direct hybrid | MAYBE — per-pair | +| Geometric | Shape boundary points | Dual quaternion products | Different filter entirely | +| Quantum | QUBO variables | COUCH tractability + QAOA | Not Sidon-based | + +The modular Filter interface (pipeline_core.py) exists precisely so +that the RIGHT filter is selected per regime. Forcing all inputs +through the CRT pipe when the input is already Sidon is the failure +mode — not the CRT engine itself. + +### The Octagon Principle Requires Regime Matching + +The octagon principle: embed nonlinear property in linear matrix, +detect via eigenvalue spectrum. The "linear matrix" is different +for each regime: + +- Combinatorial (Sidon sums): CRT adjacency matrix +- Geometric (unit distance): Euclidean distance graph +- Quantum (QUBO): energy landscape Hessian +- Physical (contention): HCMR Markov transition matrix + +Each regime has its OWN spectral signature. The octagon framework +isn't "one pipe for everything" — it's "match the spectral embedding +to the regime, then filter." + +### What the Encode Engine Provides (Revised) + +The CRT encode engine is a MODULE, not a universal preprocessor: + +1. **Sidon creation regime**: CRT wrapping criterion creates Sidon + from non-Sidon. This is the engine's PRIMARY value. The input + MUST be non-Sidon for the engine to do useful work. + +2. **Component decomposition regime**: When downstream consumers + need position-dependent constraints (geometric, toroidal/poloidal), + the CRT decomposition provides the (identity, reflection) split. + This is needed when the problem has toroidal structure. + +3. **Already-Sidon regime**: The engine is REDUNDANT. Skip it. + Use direct integer checking. The modular pipeline allows this. + +4. **Non-algebraic regime**: When the filter is geometric (COUCH) + or physical (HCMR), the CRT engine is irrelevant. Use the + appropriate spectral embedding instead. + +### The Real Test + +The encode engine's necessity is proven by showing a regime where: +1. Input is NON-Sidon +2. CRT wrapping creates Sidon (receipt: collision count drops to 0) +3. The created Sidon set enables downstream work that fails without it + +This is the C11 conjecture (new, added to attack plan): +- Input: non-Sidon label set (e.g., [0,1,2,3,4]) +- CRT embed with wrapping moduli +- Check: does collision count drop? +- If yes: engine is needed for this regime +- If no: wrapping criterion doesn't work at scale + +The framework's value is NOT that every stage is always needed. +It's that the RIGHT stage is selectable per regime. The modularity +IS the feature.